Java 如何编写实用程序类，以便使用DTO设计模式执行延迟加载？

据我所知，DTO用于将对象从一个层转移到其他层。 在我的项目中，我使用DTO将对象从持久层传输到服务层

这是我的实用程序类文件，它帮助我将持久性对象转换为DTO

物业税

    package com.cac.util;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import com.cac.hibernate.Answers;
import com.cac.hibernate.Members;
import com.cac.hibernate.Questions;
import com.cac.hibernate.Sections;
import com.cac.to.AnswersTO;
import com.cac.to.MembersTO;
import com.cac.to.QuestionsTO;
import com.cac.to.SectionsTO;
public class PropertyUtil {
    public static Sections getSectionsFromSectionsTO(SectionsTO sectionsto) {
        Sections sections=new Sections();
        sections.setSection_id(sectionsto.getSection_id());
        sections.setSection_name(sectionsto.getSection_name());
        sections.setSection_desc(sectionsto.getSection_desc());
        sections.setThreads(sectionsto.getThreads());
        sections.setPosts(sectionsto.getPosts());
        sections.setLast_post(sectionsto.getLast_post());
        sections.setLast_post_by(PropertyUtil.getMembersFromMembersTO(sectionsto.getLast_post_by()));
        sections.setQuestion_id(sectionsto.getQuestion_id());
        return sections;
    }
    public static SectionsTO getSectionsTOFromSections(Sections sections) {
        SectionsTO sectionsto=new SectionsTO();
        sectionsto.setSection_id(sections.getSection_id());
        sectionsto.setSection_name(sections.getSection_name());
        sectionsto.setSection_desc(sections.getSection_desc());
        sectionsto.setThreads(sections.getThreads());
        sectionsto.setPosts(sections.getPosts());
        sectionsto.setLast_post(sections.getLast_post());
        sectionsto.setLast_post_by(PropertyUtil.getMembersTOFromMembers(sections.getLast_post_by()));
        sectionsto.setQuestion_id(sections.getQuestion_id());
        Set<Questions> questions_set=sections.getQuestions_set();
        Set<QuestionsTO> questions_set_to=new HashSet<QuestionsTO>();
        Iterator<Questions> it=questions_set.iterator();
        while(it.hasNext()) {
            QuestionsTO questionsto=PropertyUtil.getQuestionsTOFromQuestions(it.next());
            questions_set_to.add(questionsto);
        }
        return sectionsto;
    }

    public static Members getMembersFromMembersTO(MembersTO membersto) {
        Members members=new Members();
        members.setMember_id(membersto.getMember_id());
        members.setUsername(membersto.getUsername());
        members.setPassword(membersto.getPassword());
        members.setEmail(membersto.getEmail());
        members.setGender(membersto.getGender());
        members.setBdate(membersto.getBdate());
        members.setImage_path(membersto.getImage_path());
        members.setAddress(membersto.getAddress());
        members.setBest_at(membersto.getBest_at());
        members.setPosition(membersto.getPosition());
        members.setJoin_date(membersto.getJoin_date());
        //Set<Members> memset=new HashSet<Members>();

        //members.setQuestions_set(membersto.getQuestionsto_set());
        //mem
        return members;
    }
    public static MembersTO getMembersTOFromMembers(Members members) {
        MembersTO membersto=new MembersTO();
        membersto.setMember_id(members.getMember_id());
        membersto.setUsername(members.getUsername());
        membersto.setPassword(members.getPassword());
        membersto.setEmail(members.getEmail());
        membersto.setGender(members.getGender());
        membersto.setBdate(members.getBdate());
        membersto.setImage_path(members.getImage_path());
        membersto.setAddress(members.getAddress());
        membersto.setBest_at(members.getBest_at());
        membersto.setPosition(members.getPosition());
        membersto.setJoin_date(members.getJoin_date());
        Set<Questions> questions_set=members.getQuestions_set();
        Set<QuestionsTO> questions_set_to=new HashSet<QuestionsTO>();
        Iterator<Questions> it=questions_set.iterator();
        while(it.hasNext()) {
            QuestionsTO questionsto=PropertyUtil.getQuestionsTOFromQuestions(it.next());
            questions_set_to.add(questionsto);
        }
        Set<Answers> answers_set=members.getAnswers_set();
        Set<AnswersTO> answers_set_to=new HashSet<AnswersTO>();
        Iterator<Answers> answers_it=answers_set.iterator();
        while(answers_it.hasNext()) {
            AnswersTO answersto=PropertyUtil.getAnswersTOFromAnswers(answers_it.next());
            answers_set_to.add(answersto);
        }
        //members.setQuestions_set(membersto.getQuestionsto_set());
        //mem
        return membersto;
    }
    public static QuestionsTO getQuestionsTOFromQuestions(Questions questions) {
        QuestionsTO questionsto=new QuestionsTO();
        questionsto.setQuestion_id(questions.getQuestion_id());
        questionsto.setQuestion_title(questions.getQuestion_title());
        questionsto.setQuestion_desc(questions.getQuestion_desc());
        questionsto.setQ_post_date(questions.getQ_post_date());
        questionsto.setReplies(questions.getReplies());
        questionsto.setViews(questions.getViews());
        questionsto.setLast_post_by(questions.getLast_post_by());
        questionsto.setLast_post_date(questions.getLast_post_date());

        Set<Answers> answers_set=questions.getAnswers_set();
        Set<AnswersTO> answers_set_to=new HashSet<AnswersTO>();
        Iterator<Answers> answers_it=answers_set.iterator();
        while(answers_it.hasNext()) {
            AnswersTO answersto=PropertyUtil.getAnswersTOFromAnswers(answers_it.next());
            answers_set_to.add(answersto);
        }
        return questionsto;
    }
    public static Questions getQuestionsFromQuestionsTO(QuestionsTO questionsto) {
        Questions questions=new Questions();
        questions.setQuestion_id(questionsto.getQuestion_id());
        questions.setQuestion_title(questionsto.getQuestion_title());
        questions.setQuestion_desc(questionsto.getQuestion_desc());
        questions.setQ_post_date(questionsto.getQ_post_date());
        questions.setReplies(questionsto.getReplies());
        questions.setViews(questionsto.getViews());
        questions.setLast_post_by(questionsto.getLast_post_by());
        questions.setLast_post_date(questionsto.getLast_post_date());

        return questions;
    }

    public static AnswersTO getAnswersTOFromAnswers(Answers answers) {
        AnswersTO answersto=new AnswersTO();
        answersto.setAnswer_id(answers.getAnswer_id());
        answersto.setAnswer_desc(answers.getAnswer_desc());
        answersto.setA_post_date(answers.getA_post_date());

        return answersto;
    }
    public static Answers getAnswersFromAnswersTO(AnswersTO answersto) {
        Answers answers=new Answers();
        answers.setAnswer_id(answersto.getAnswer_id());
        answers.setAnswer_desc(answersto.getAnswer_desc());
        answers.setA_post_date(answersto.getA_post_date());

        return answers;
    }
}

package com.cac.util；
导入java.util.HashSet；
导入java.util.Iterator；
导入java.util.Set；
导入com.cac.hibernate.Answers；
导入com.cac.hibernate.Members；
导入com.cac.hibernate.Questions；
导入com.cac.hibernate.Sections；
导入com.cac.to.AnswersTO；
导入com.cac.to.MembersTO；
将com.cac.to.questions导入；
导入com.cac.to.SectionsTO；
公共类属性直到{
公共静态部分getSectionsFromSectionsTO（SectionsToSectionsTo）{
节=新节（）；
sections.setSection_id（sections to.getSection_id（））；
sections.setSection_name（sections sto.getSection_name（））；
sections.setSection_desc（sections to.getSection_desc（））；
sections.setThreads（sectionsto.getThreads（））；
sections.setPosts（sectionsto.getPosts（））；
sections.setLast_post（sections to.getLast_post（））；
sections.setLast\u post\u by（PropertyUtil.getMembersFromMembersTO（sections sto.getLast\u post\u by（））；
sections.setQuestion_id（sectionsto.getQuestion_id（））；
回流段；
}
公共静态节到获取节到从节（节）{
SectionsTO SectionsTO=新的SectionsTO（）；
sections to.setSection_id（sections.getSection_id（））；
sections sto.setSection_name（sections.getSection_name（））；
sections to.setSection_desc（sections.getSection_desc（））；
sectionsto.setThreads（sections.getThreads（））；
sections to.setPosts（sections.getPosts（））；
sections to.setLast_post（sections.getLast_post（））；
sections to.setLast_post_by（PropertyUtil.getMembersTOFromMembers（sections.getLast_post_by（））；
sectionsto.setQuestion_id（sections.getQuestion_id（））；
设置问题集=节。获取问题集（）；
将问题设置为=新HashSet（）；
迭代器it=questions_set.Iterator（）；
while（it.hasNext（））{
questions to questions sto=PropertyUtil.getquestions stofromQuestions（it.next（））；
问题设置到。添加（问题到）；
}
返回段STO；
}
公共静态成员getMembersFromMembersTO（MembersToMembersTo）{
成员=新成员（）；
members.setMember_id（membersto.getMember_id（））；
members.setUsername（membersto.getUsername（））；
members.setPassword（membersto.getPassword（））；
members.setEmail（membersto.getEmail（））；
members.setGender（membersto.getGender（））；
members.setBdate（membersto.getBdate（））；
members.setImage_path（membersto.getImage_path（））；
members.setAddress（membersto.getAddress（））；
members.setBest_at（membersto.getBest_at（））；
members.setPosition（membersto.getPosition（））；
members.setJoin_date（membersto.getJoin_date（））；
//Set memset=newhashset（）；
//members.setQuestions_set（membersto.getquestions_set（））；
//记忆
返回成员；
}
公共静态成员getMembersTOFromMembers（成员）{
MembersTO MembersTO=新成员sTo（）；
membersto.setMember_id（members.getMember_id（））；
membersto.setUsername（members.getUsername（））；
membersto.setPassword（members.getPassword（））；
membersto.setEmail（members.getEmail（））；
membersto.setGender（members.getGender（））；
membersto.setBdate（members.getBdate（））；
membersto.setImage_path（members.getImage_path（））；
membersto.setAddress（members.getAddress（））；
membersto.setBest_at（members.getBest_at（））；
membersto.setPosition（members.getPosition（））；
membersto.setJoin_date（members.getJoin_date（））；
设置问题集=成员。获取问题集（）；
将问题设置为=新HashSet（）；
迭代器it=questions_set.Iterator（）；
while（it.hasNext（））{
questions to questions sto=PropertyUtil.getquestions stofromQuestions（it.next（））；
问题设置到。添加（问题到）；
}
Set answers\u Set=members.getAnswers\u Set（）；
将答案设置为=新HashSet（）；
迭代器answers_it=answers_set.Iterator（）；
while（answers_it.hasNext（））{
AnswersTO AnswersTO=PropertyUtil.getAnswersTOFromAnswers（answers\u it.next（））；
答案设置为。添加（答案为）；
}
//members.setQuestions_set（membersto.getquestions_set（））；
//记忆
返回成员至；
}
公共静态问题从问题中获取问题（问题）{
questions to questions sto=新问题sto（）；
questions to.setQuestion_id（questions.getQuestion_id（））；
questions to.setQuestion_title（questions.getQuestion_title（））；
questions to.setQuestion_desc（questions.getQuestion_desc（））；
questions to.setQ_post_date（questions.getQ_post_date（））；
questions to.setReplies（questions.getReplies（））；
questions to.setViews（questions.getViews（））；
questions to.setLast_post_by（questions.getLast_post_by（））；
questions to.setLast_post_date（questions.getLast_post_date（））；
设置答案集=问题。获取答案集（）；
将答案设置为=新HashSet（）；
迭代器answers_it=answers_set.Iterator（）；
while（answers_it.hasNext（））{
AnswersTO AnswersTO=PropertyUtil.getAnswersTOFromAnswers（answers\u it.next（））；
答案设置为。添加（答案为）；
}
返回问题至；
}
公共静态问题getQuestionsFromQuestionsTO（问题ToQuestionsTo）{
问题=新问题（）；
questions.setQuestion_id（questions to.getQuestion_id（））；
questions.setQuestion_title（questions to.getQuestion_title（））；
阙
session.createQuery("from Sections sections");