Java 如何通过Criteria Builder使用多个根执行选择查询

我对使用criteria builder非常陌生，所以这是我第一次尝试。我尝试使用多个实体类，所以我使用多个根来比较这些东西。我觉得我在第一个方法末尾的select语句是错误的，因为我没有将这两个根都合并到它中。特别是因为我使用sl和sld来比较谓词where子句中的内容。我需要加入他们吗？我将来如何添加更多的类？如果我想从每个表中选择特定的内容以返回到自定义对象中，是否必须更改select语句？谢谢

拉式选择语句：

cq.select(sl);
cq.where(predicates.toArray(new Predicate[] {}));

全班：

@Repository
public class DealerTotalsQueryRepository {

    private static final String START_DATE = "0001-01-01";
    private static final String TERMINATION_DATE = "terminationDate";
    private static final String KEY = "key";
    private static final String DEALER_CODE = "dealerCode";
    private static final String SERVICE_LETTER_NUMBER = "serviceLetterNumber";
    private static final String OPEN_COMPLETE_IND_O = "O";
    private static final String OPEN_COMPLETE_IND_C = "C";
    private static final String COMPLETION_DATE = "completionDate";
    private static final String TERM_IND_NTERM = "nterm";
    private static final String TERM_IND_TERM = "term";
    private static final String SERVICE_LETTER_DATE = "serviceLetterDate";

    @PersistenceContext
    private EntityManager em;

    public List < ServiceLetter > findAllServiceLetters(Map < String, String > searchCriteriaData) {

        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery < ServiceLetter > cq = cb.createQuery(ServiceLetter.class);

        Root < ServiceLetter > sl = cq.from(ServiceLetter.class);
        Root < ServiceLetterDesc > sld = cq.from(ServiceLetterDesc.class);

        List < Predicate > predicates = new ArrayList < > ();

        String marketOrg = searchCriteriaData.get(GlobalConstants.MARKET_ORG);
        String dealerCd = searchCriteriaData.get(GlobalConstants.DEALER_CD);
        String programNo = searchCriteriaData.get(GlobalConstants.PROGRAM_NO);
        String openCompleteInd = searchCriteriaData.get(GlobalConstants.OPEN_COMPLETE_IND);
        String termInd = searchCriteriaData.get(GlobalConstants.TERM_IND);
        String dateFrom = searchCriteriaData.get(GlobalConstants.DATE_FROM);
        String dateTo = searchCriteriaData.get(GlobalConstants.DATE_TO);
        String pinPrefix = searchCriteriaData.get(GlobalConstants.SERIAL_NO_PREFIX);
        String letterType = searchCriteriaData.get(GlobalConstants.LETTER_TYPE);
        java.sql.Date currentDate = new java.sql.Date(System.currentTimeMillis());

        if (marketOrg != null && !marketOrg.isEmpty()) {
            //predicates.add(cb.equal(sl.get(""), ""));
        }
        if (dealerCd != null && !dealerCd.isEmpty()) {
            predicates.add(cb.equal(sl.get(KEY).get(DEALER_CODE), dealerCd));
        }
        if (programNo != null && !programNo.isEmpty()) {
            predicates.add(cb.equal(sl.get(KEY).get(SERVICE_LETTER_NUMBER), programNo));
        } else {
            predicates.add(pipPspIndCodeClause(cb, sld, letterType));
        }

        if (openCompleteInd != null && !openCompleteInd.equalsIgnoreCase("all")) {
            if (openCompleteInd.equalsIgnoreCase(OPEN_COMPLETE_IND_O)) {
                predicates.add(cb.equal(sl.get(COMPLETION_DATE), START_DATE));
            } else if (openCompleteInd.equalsIgnoreCase(OPEN_COMPLETE_IND_C)) {
                predicates.add(cb.notEqual(sl.get(COMPLETION_DATE), START_DATE));
            }
        }
        if (termInd != null && !termInd.equalsIgnoreCase("all")) {
            if (termInd.equalsIgnoreCase(TERM_IND_NTERM)) {
                Predicate termEToStart = cb.equal(sld.get(TERMINATION_DATE), START_DATE);
                Predicate termGTCurrentDate = cb.greaterThan(sld.get(TERMINATION_DATE), currentDate);
                predicates.add(cb.or(termEToStart, termGTCurrentDate));
            } else if (termInd.equalsIgnoreCase(TERM_IND_TERM)) {
                Predicate termGTStartDate = cb.greaterThan(sld.get(TERMINATION_DATE), START_DATE);
                Predicate termLTOETCurrentDate = cb.lessThanOrEqualTo(sld.get(TERMINATION_DATE), currentDate);
                predicates.add(cb.and(termGTStartDate, termLTOETCurrentDate));
            }
        }
        if (dateFrom != null && !dateFrom.isEmpty()) {
            predicates.add(cb.between(sld.get(SERVICE_LETTER_DATE), dateFrom, dateTo));
        }
        if (pinPrefix != null && pinPrefix.isEmpty()) {
            /*          buff.append("AND A.SER_NO_PFX IN (" + setupWhereIn(pv, parms.get(ChooseQuery.PIN_PREFIX_KEY), true, 3) + ") "); */

        }
        cq.select(sl);
        cq.where(predicates.toArray(new Predicate[] {}));

        TypedQuery < ServiceLetter > q = em.createQuery(cq);
        return q.getResultList();
    }

    private Predicate pipPspIndCodeClause(CriteriaBuilder cb, Root < ServiceLetterDesc > sld, String letterType) {

        Predicate pipPspIndCode = null;
        Predicate predTemp1 = null;
        Predicate predTemp2 = null;
        Predicate predTemp3 = null;
        Predicate predTemp4 = null;

        List < String > serviceLetterNumberList = Arrays.asList(new String[] {
            "956151",
            "956170"
        });
        Expression < String > serviceLetterNumberExpression = sld.get(SERVICE_LETTER_NUMBER);

        if (letterType != null && !letterType.equalsIgnoreCase("all")) {
            switch (letterType) {
                case "pip":
                    pipPspIndCode = cb.like(sld.get(SERVICE_LETTER_NUMBER), "94%");
                    break;
                case "pipsaf":
                    predTemp1 = cb.like(sld.get(SERVICE_LETTER_NUMBER), "940%");
                    predTemp2 = cb.like(sld.get(SERVICE_LETTER_NUMBER), "941%");
                    pipPspIndCode = cb.or(predTemp1, predTemp2);
                    break;
                case "pippri":
                    pipPspIndCode = cb.like(sld.get(SERVICE_LETTER_NUMBER), "943%");
                    break;
                case "psp":
                    pipPspIndCode = cb.like(sld.get(SERVICE_LETTER_NUMBER), "95%");
                    break;
                case "pspbaf":
                    predTemp1 = cb.like(sld.get(SERVICE_LETTER_NUMBER), "954%");
                    predTemp2 = cb.like(sld.get(SERVICE_LETTER_NUMBER), "958%");
                    predTemp3 = cb.or(predTemp1, predTemp2);

                    predTemp4 = cb.between(sld.get(SERVICE_LETTER_NUMBER), "9590016", "9590109");
                    pipPspIndCode = cb.or(predTemp3, predTemp4);
                    break;
                case "pspaf":
                    predTemp1 = cb.like(sld.get(SERVICE_LETTER_NUMBER), "955%");
                    predTemp2 = cb.between(sld.get(SERVICE_LETTER_NUMBER), "9560000", "9560027");
                    predTemp3 = cb.or(predTemp1, predTemp2);

                    predTemp4 = serviceLetterNumberExpression.in(serviceLetterNumberList);
                    pipPspIndCode = cb.or(predTemp3, predTemp4);

                    //predTemp4 = cb.in(sld.get(SERVICE_LETTER_NUMBER)).value(serviceLetterNumberList);
                    break;
                case "pspcn9":
                    pipPspIndCode = cb.between(sld.get(SERVICE_LETTER_NUMBER), "9590110", "9599999");
                    break;
                case "pspcn6":
                    predTemp1 = cb.between(sld.get(SERVICE_LETTER_NUMBER), "9590110", "9599999");
                    predTemp2 = serviceLetterNumberExpression.in(serviceLetterNumberList).not();
                    pipPspIndCode = cb.or(predTemp1, predTemp2);
                    break;
            }
        }
        return pipPspIndCode;
    }
}

@存储库
公共类DealTotalQueryRepository{
专用静态最终字符串开始\u DATE=“0001-01-01”；
私有静态最终字符串终止\u DATE=“terminationDate”；
私有静态最终字符串KEY=“KEY”；
私有静态最终字符串DEALER\u CODE=“dealerCode”；
专用静态最终字符串服务\u LETTER\u NUMBER=“serviceLetterNumber”；
私有静态最终字符串OPEN\u COMPLETE\u IND\u O=“O”；
私有静态最终字符串OPEN\u COMPLETE\u IND\u C=“C”；
私有静态最终字符串完成\u DATE=“completionDate”；
私有静态最终字符串项\u IND\u NTERM=“NTERM”；
私有静态最终字符串TERM\u IND\u TERM=“TERM”；
私有静态最终字符串服务\u LETTER\u DATE=“serviceLetterDate”；
@持久上下文
私人实体管理者；
公共列表findAllServiceLetters（映射searchCriteriaData）{
CriteriaBuilder cb=em.getCriteriaBuilder（）；
CriteriaQuerycq=cb.createQuery（ServiceLetter.class）；
Rootsl=cq.from（ServiceLetter.class）；
Rootsld=cq.from（ServiceLetterDesc.class）；
Listpredicates=newarraylist<>（）；
字符串marketOrg=searchCriteriaData.get（GlobalConstants.MARKET_ORG）；
String dealerCd=searchCriteriaData.get（GlobalConstants.DEALER\u CD）；
String programNo=searchCriteriaData.get（GlobalConstants.PROGRAM_NO）；
字符串openCompleteInd=searchCriteriaData.get（GlobalConstants.OPEN\u COMPLETE\u IND）；
String termInd=searchCriteriaData.get（GlobalConstants.TERM\u IND）；
String dateFrom=searchCriteriaData.get（GlobalConstants.DATE\u FROM）；
String dateTo=searchCriteriaData.get（GlobalConstants.DATE\u TO）；
String pinPrefix=searchCriteriaData.get（GlobalConstants.SERIAL\u NO\u前缀）；
String letterType=searchCriteriaData.get（GlobalConstants.LETTER_-TYPE）；
java.sql.Date currentDate=新的java.sql.Date（System.currentTimeMillis（））；
if（marketOrg！=null&&！marketOrg.isEmpty（））{
//add（cb.equal（sl.get（“”“”））；
}
if（dealerCd！=null&&！dealerCd.isEmpty（））{
add（cb.equal（sl.get（KEY）.get（DEALER_CODE），dealerCd））；
}
if（programNo！=null&&！programNo.isEmpty（））{
add（cb.equal（sl.get（KEY）.get（SERVICE_字母_编号），programNo））；
}否则{
add（pipppindcodeclause（cb，sld，letterType））；
}
if（openCompleteInd！=null&！openCompleteInd.equalsIgnoreCase（“全部”））{
if（openCompleteInd.equalsIgnoreCase（OPEN\u COMPLETE\u IND\O））{
add（cb.equal（sl.get（完成日期），开始日期））；
}else if（openCompleteInd.equalsIgnoreCase（OPEN\u COMPLETE\u IND\u C））{
add（cb.notEqual（sl.get（完成日期），开始日期））；
}
}
if（termInd！=null&！termInd.equalsIgnoreCase（“全部”））{
if（终止相等信号情况（终止）{
谓词termEToStart=cb.equal（sld.get（终止日期）、开始日期）；
谓词termGTCurrentDate=cb.greaterThan（sld.get（终止日期），currentDate）；
add（cb.or（termEToStart，termtcurrentdate））；
}else if（终止相等信号情况（术语独立术语））{
谓词termGTStartDate=cb.greaterThan（sld.get（终止日期）、开始日期）；
谓词termLTOETCurrentDate=cb.LESSTHANORREQUALTO（sld.get（终止日期），currentDate）；
add（cb.and（termGTStartDate，termlotecurrentdate））；
}
}
if（dateFrom！=null&！dateFrom.isEmpty（））{
add（cb.between（sld.get（SERVICE_LETTER_DATE）、dateFrom、dateTo））；
}
if（pinPrefix！=null&&pinPrefix.isEmpty（））{
/*buff.append（“+setupwhere（pv，parms.get（ChooseQuery.PIN\u PREFIX\u KEY），true，3）+”中的A.SER\u NO\u PFX）*/
}
选择（sl）；
cq.where（谓词.toArray（新谓词[]{}））；
TypedQueryq=em.createQuery（cq）；
返回q.getResultList（）；
}
私有谓词pipppindcodeclause（CriteriaBuilder cb，根sld，字符串letterType）{
谓词pipppindcode=null；
谓词predTemp1=null；
谓词predTemp2=null；
谓词predTemp3=null；
谓词predTemp4=null；
ListserviceLetterNumberList=Arrays.asList（新字符串[]）{
"956151",
"956170"
});
表达式ServiceLetterNumberPression=sld.get（服务字母编号）；
if（letterType！=null&！letterType.equalsIgnoreCase（“全部”））{
开关（字体）{
案例“pip”：
pipppindcode=cb.like（sld.get（服务字母编号），“94%”；
打破
案例“pipsaf”：
predTemp1=cb.like（sld.get（服务字母编号），“940%”；
predTemp2=cb.like（sld.get（服务字母编号），“941%”；