Spring Boot JPA规范动态生成SQL，如何改进它？

Question

现在，我已经习惯了Spring-Boot版本2.4.3，我们主要使用Spring-Boot JPA。

public class ReportSpecification implements Specification<Report> {
    private Long userId;
    private String name;

    @Override
    public Predicate toPredicate(Root<Report> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
        List<Predicate> predicates = Lists.newArrayList();

        if (ObjectUtils.isNotEmpty(userId))
            predicates.add(criteriaBuilder.equal(root.get(Report_.user).get(User_.id), userId));

        if (Strings.isNotBlank(name))
            predicates.add(criteriaBuilder.equal(root.get(Report_.name), name));

        return criteriaBuilder.and(Iterables.toArray(predicates, Predicate.class));
    }
}

这只是示例代码，但实际上更复杂，规范类希望它是通用的，如果此方法中的句子是一个超过10个，因为它的目的是一个对一个规范类的表，它可以动态生成SQL。

我的问题是，如果这种方法中的语句会有很多，所以我希望该代码可以更可读，有人可以给我一些建议，或者我如何使用哪种设计模式来重构此方法，或者有任何方法可以改善它？

Answer 1

规范是一个小的单点类，一个谓词确定对象是否满足某些标准。每个简单标准实现一项规范是灵活的。如果规则很复杂，则可以将简单规格组合在一起，就像谓词与逻辑运算符结合在一起。

主要思想是将大规格分为可重复使用的小块，并通过复合图案组合。

用户ID的规范：

    public static Specification<Report> byUserId(Long userId) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (ObjectUtils.isNotEmpty(userId)) {
                predicate = criteriaBuilder.equal(root.get("user").get("id"), userId);
            }
            return predicate;
        };
    }

reportname的规范：

    public static Specification<Report> byReportName(String reportName) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (Strings.isNotBlank(reportName)) {
                predicate = criteriaBuilder.equal(root.get("name"), reportName);
            }
            return predicate;
        };
    }

组合规格：

    public static Specification<Report> reportCompositeSpecification(ReportCriteria reportCriteria) {
        return combine(getSpecifications(reportCriteria));
    }
    
    private static <T> Specification<T> combine(Collection<Specification<T>> specifications) {
        Specification<T> combinedSpecification = null;
        for (Specification<T> specification : specifications) {
            if (combinedSpecification == null) {
                combinedSpecification = Specification.where(specification);
            } else {
                combinedSpecification = combinedSpecification.and(specification);
            }
        }
        return combinedSpecification;        
    }

    public static List<Specification<Report>> getSpecifications(ReportCriteria reportCriteria) {
        return Stream.of(byUserId(reportCriteria.getUserId()),
                         byReportName(reportCriteria.getName()))
                     .collect(Collectors.toList());
    }

< < 实现：​​

public class ReportSpecification implements Specification<Report> {

    private final ReportCriteria reportCriteria;

    public ReportSpecification(ReportCriteria reportCriteria) {
        this.reportCriteria = reportCriteria;
    }

    @Override
    public Predicate toPredicate(Root<Report> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
        return reportCompositeSpecification(reportCriteria).toPredicate(root, query, criteriaBuilder);
    }

    public static Specification<Report> reportCompositeSpecification(ReportCriteria reportCriteria) {
        return combine(getSpecifications(reportCriteria));
    }

    private static <T> Specification<T> combine(Collection<Specification<T>> specifications) {
        Specification<T> combinedSpecification = null;
        for (Specification<T> specification : specifications) {
            if (combinedSpecification == null) {
                combinedSpecification = Specification.where(specification);
            } else {
                combinedSpecification = combinedSpecification.and(specification);
            }
        }
        return combinedSpecification;
    }

    public static List<Specification<Report>> getSpecifications(ReportCriteria reportCriteria) {
        return Stream.of(byUserId(reportCriteria.getUserId()),
                         byReportName(reportCriteria.getName()))
                     .collect(Collectors.toList());
    }

    public static Specification<Report> byUserId(Long userId) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (ObjectUtils.isNotEmpty(userId)) {
                predicate = criteriaBuilder.equal(root.get("user").get("id"), userId);
            }
            return predicate;
        };
    }

    public static Specification<Report> byReportName(String reportName) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (Strings.isNotBlank(reportName)) {
                predicate = criteriaBuilder.equal(root.get("name"), reportName);
            }
            return predicate;
        };
    }
}

public class ReportCriteria {
    private Long userId;
    private String name;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

用法的示例：

import static com.test.repository.specification.ReportSpecification.*;

        ReportCriteria reportCriteria = new ReportCriteria();
        reportCriteria.setName("name");
        reportCriteria.setUserId(1L);
        reportRepository.findAll(reportCompositeSpecification(reportCriteria));

或

        ReportCriteria reportCriteria = new ReportCriteria();
        reportCriteria.setName(null);
        reportCriteria.setUserId(1L);
        return reportRepository.findAll(new ReportSpecification(reportCriteria));

强>完整

import static com.test.repository.specification.ReportSpecification.*;

        ReportCriteria criteria = new ReportCriteria();
        criteria.setName("name");
        criteria.setUserId(1L);
        return reportRepository.findAll(byUserId(criteria.getUserId()).and(byReportName(criteria.getName())));

优点：

• 您具有灵活的简单规格，可以在其他上下文
• 解决方案中合并或重复使用这些规格。您只需实施新规范，然后将其注册在Common Collection getspecifications（Report Criteria Report Criteria）

参考文献

规格-Martin Fowler

domain-driend-drive design：在软件中心解决复杂性

< < < < < < br> 也没有共同的联合方法更简单的实现：

public class ReportSpecification implements Specification<Report> {
    private final ReportCriteria reportCriteria;

    public ReportSpecification(ReportCriteria reportCriteria) {
        this.reportCriteria = reportCriteria;
    }

    @Override
    public Predicate toPredicate(Root<Report> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
        return byUserId(reportCriteria.getUserId()).and(byReportName(reportCriteria.getName()))
                .toPredicate(root, query, criteriaBuilder);
    }

    public static Specification<Report> byUserId(Long userId) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (ObjectUtils.isNotEmpty(userId)) {
                predicate = criteriaBuilder.equal(root.get("user").get("id"), userId);
            }
            return predicate;
        };
    }

    public static Specification<Report> byReportName(String reportName) {
        return (root, query, criteriaBuilder) -> {
            Predicate predicate = null;
            if (Strings.isNotBlank(reportName)) {
                predicate = criteriaBuilder.equal(root.get("name"), reportName);
            }
            return predicate;
        };
    }
}