java jpa 规范_Java：在JPA中使用规范模式

51 阅读 0 评论 34 点赞

我是靠谱客的博主鲤鱼世界，最近开发中收集的这篇文章主要介绍java jpa 规范_Java：在JPA中使用规范模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

java jpa 规范

本文是在Java中使用规范模式的简介。我们还将看到如何将经典规范与JPA Criteria查询结合使用，以从关系数据库中检索对象。

在本文中，我们将使用以下Poll类作为创建规范的示例实体。它表示具有开始和结束日期的民意调查。在这两个日期之间的时间中，用户可以在不同的选择之间进行投票。到达结束日期之前，管理员还可以锁定民意调查。在这种情况下，将设置锁定日期。

@Entity
public class Poll { 
  @Id
  @GeneratedValue
  private long id;
  private DateTime startDate; 
  private DateTime endDate;
  private DateTime lockDate;
  @OneToMany(cascade = CascadeType.ALL)
  private List<Vote> votes = new ArrayList<>();
}

为了获得更好的可读性，我跳过了用于映射此示例中不需要的Joda DateTime实例和字段的getter，setter，JPA批注（例如民意调查中提出的问题）。

现在假设我们要实现两个约束：

如果未锁定且startDate <now <endDate，则轮询当前正在运行
如果民意调查的投票数超过100并且未锁定，则该投票很受欢迎

我们可以从向Poll添加适当的方法开始，例如：poll.isCurrentlyRunning（）。另外，我们可以使用类似pollService.isCurrentlyRunning（poll）的服务方法。但是，我们还希望能够查询数据库以获取所有当前正在运行的民意调查。因此，我们可以添加DAO或存储库方法，例如pollRepository.findAllCurrentlyRunningPolls（）。

如果采用这种方式，我们将在两个不同的位置两次实现isCurrentlyRunning约束。如果我们要结合约束，事情就会变得更糟。如果我们想查询数据库以获取当前正在运行的所有流行民意测验的列表怎么办？

这是规范模式派上用场的地方。使用规范模式时，我们将业务规则移到称为规范的额外类中。

首先，我们创建一个简单的界面和一个抽象类：

public interface Specification<T> {  
  boolean isSatisfiedBy(T t);  
  Predicate toPredicate(Root<T> root, CriteriaBuilder cb);
  Class<T> getType();
}

abstract public class AbstractSpecification<T> implements Specification<T> {
  @Override
  public boolean isSatisfiedBy(T t) {
    throw new NotImplementedException();
  }  
  @Override
  public Predicate toPredicate(Root<T> poll, CriteriaBuilder cb) {
    throw new NotImplementedException();
  }
  @Override
  public Class<T> getType() {
    ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
    return (Class<T>) type.getActualTypeArguments()[0];
  }
}

请暂时忽略带有神秘的getType（）方法的AbstractSpecification <T>类（我们稍后再介绍）。

规范的中心部分是isSatisfiedBy（）方法，该方法用于检查对象是否满足规范。 toPredicate（）是我们在本示例中使用的另一种方法，用于以javax.persistence.criteria.Predicate实例的形式返回约束，该约束可用于查询数据库。

对于每个约束，我们创建一个新的规范类，该类扩展AbstractSpecification <T>并实现isSatisfiedBy（）和toPredicate（）。

检查轮询是否正在运行的规范实现如下所示：

public class IsCurrentlyRunning extends AbstractSpecification<Poll> {
  @Override
  public boolean isSatisfiedBy(Poll poll) {
    return poll.getStartDate().isBeforeNow() 
        && poll.getEndDate().isAfterNow() 
        && poll.getLockDate() == null;
  }
  @Override
  public Predicate toPredicate(Root<Poll> poll, CriteriaBuilder cb) {
    DateTime now = new DateTime();
    return cb.and(
      cb.lessThan(poll.get(Poll_.startDate), now),
      cb.greaterThan(poll.get(Poll_.endDate), now),
      cb.isNull(poll.get(Poll_.lockDate))
    );
  }
}

在isSatisfiedBy（）中，我们检查传递的对象是否与约束匹配。在toPredicate（）中，我们使用JPA的CriteriaBuilder构造谓词。稍后，我们将使用结果谓词实例来构建用于查询数据库的CriteriaQuery。

用于检查民意调查是否受欢迎的规范看起来类似：

public class IsPopular extends AbstractSpecification<Poll> {
  @Override
  public boolean isSatisfiedBy(Poll poll) {
    return poll.getLockDate() == null && poll.getVotes().size() > 100;
  }  
  @Override
  public Predicate toPredicate(Root<Poll> poll, CriteriaBuilder cb) {
    return cb.and(
      cb.isNull(poll.get(Poll_.lockDate)),
      cb.greaterThan(cb.size(poll.get(Poll_.votes)), 5)
    );
  }
}

如果现在要测试Poll实例是否符合以下约束之一，则可以使用我们新创建的规范：

boolean isPopular = new IsPopular().isSatisfiedBy(poll);
boolean isCurrentlyRunning = new IsCurrentlyRunning().isSatisfiedBy(poll);

为了查询数据库，我们需要扩展DAO /存储库以支持规范。看起来可能如下所示：

public class PollRepository {
  private EntityManager entityManager = ...
  public <T> List<T> findAllBySpecification(Specification<T> specification) {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    // use specification.getType() to create a Root<T> instance
    CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(specification.getType());
    Root<T> root = criteriaQuery.from(specification.getType());
    // get predicate from specification
    Predicate predicate = specification.toPredicate(root, criteriaBuilder);
    // set predicate and execute query
    criteriaQuery.where(predicate);
    return entityManager.createQuery(criteriaQuery).getResultList();
  }
}

在这里，我们最终使用在AbstractSpecification <T>中实现的getType（）方法来创建CriteriaQuery <T>和Root <T>实例。 getType（）返回由子类定义的AbstractSpecification <T>实例的泛型类型。对于IsPopular和IsCurrentlyRunning，它返回Poll类。如果没有getType（），我们将不得不在我们创建的每个规范的toPredicate（）内创建CriteriaQuery <T>和Root <T>实例。因此，减少规范内的样板代码只是一个小帮手。如果您想出更好的方法，请随时用自己的实现替换它。

现在，我们可以使用我们的存储库来查询数据库以查找与特定规范匹配的民意测验：

List<Poll> popularPolls = pollRepository.findAllBySpecification(new IsPopular());
List<Poll> currentlyRunningPolls = pollRepository.findAllBySpecification(new IsCurrentlyRunning());

在这一点上，规范是唯一包含约束定义的组件。我们可以使用它来查询数据库或检查对象是否满足必需的规则。

但是，仍然存在一个问题：我们如何结合两个或更多个约束？例如，我们想查询数据库以获取所有仍在运行的流行民意调查。

答案是复合设计模式的一种变化，称为复合规格。使用复合规范，我们可以以不同方式组合规范。

要查询数据库中所有正在运行和流行的池，我们需要使用逻辑和操作将isCurrentlyRunning与isPopular规范结合在一起。让我们为此创建另一个规范。我们将其命名为AndSpecification：

public class AndSpecification<T> extends AbstractSpecification<T> {
  private Specification<T> first;
  private Specification<T> second;
  public AndSpecification(Specification<T> first, Specification<T> second) {
    this.first = first;
    this.second = second;
  }
  @Override
  public boolean isSatisfiedBy(T t) {
    return first.isSatisfiedBy(t) && second.isSatisfiedBy(t);
  }
  @Override
  public Predicate toPredicate(Root<T> root, CriteriaBuilder cb) {
    return cb.and(
      first.toPredicate(root, cb), 
      second.toPredicate(root, cb)
    );
  }
  @Override
  public Class<T> getType() {
    return first.getType();
  }
}

AndSpecification是从其他两个规范中创建的。在isSatisfiedBy（）和toPredicate（）中，我们通过逻辑和运算返回两个规范的结果。

我们可以像这样使用我们的新规范：

Specification<Poll> popularAndRunning = new AndSpecification<>(new IsPopular(), new IsCurrentlyRunning());
List<Poll> polls = myRepository.findAllBySpecification(popularAndRunning);

为了提高可读性，我们可以在规范接口中添加and（）方法：

public interface Specification<T> {
  Specification<T> and(Specification<T> other);
  // other methods
}

并在我们的抽象实现中实现它：

abstract public class AbstractSpecification<T> implements Specification<T> {
  @Override
  public Specification<T> and(Specification<T> other) {
    return new AndSpecification<>(this, other);
  }
  // other methods
}

现在，我们可以使用and（）方法链接多个规范：

Specification<Poll> popularAndRunning = new IsPopular().and(new IsCurrentlyRunning());
boolean isPopularAndRunning = popularAndRunning.isSatisfiedBy(poll);
List<Poll> polls = myRepository.findAllBySpecification(popularAndRunning);

在需要时，我们可以轻松地通过其他复合规范（例如OrSpecification或NotSpecification）进一步扩展该规范。