Java Spring数据JPA存储库匹配所有列或整个pojo

我试图搜索，但没有找到准确的答案。我有

地址

实体。对于每个新的地址请求，首先我要检查数据库中是否存在相同的地址。我的申请是仓库&同样的地址请求可能会多次出现

地址实体

@Entity
@NamedQuery(name="Address.findAll", query="SELECT a FROM Address a")
public class Address implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;

    private String firstname;

    private String lastname;

    private String address1;

    private String address2;

    private String address3;

    private String city;

    private String postcode;

    @JsonProperty(value="county")
    private String state;

    private String country;

    private String telephoneno;

    private String mobileno;    

    private String email;

    //bi-directional many-to-one association to Collection
    @OneToMany(mappedBy="address")
    @JsonIgnore
    private List<Collection> collections;

    //bi-directional many-to-one association to Delivery
    @OneToMany(mappedBy="address")
    @JsonIgnore
    private List<Delivery> deliveries;


    public Address() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAddress1() {
        return this.address1;
    }

    public void setAddress1(String address1) {
        this.address1 = address1;
    }

    public String getAddress2() {
        return this.address2;
    }

    public void setAddress2(String address2) {
        this.address2 = address2;
    }

    public String getAddress3() {
        return this.address3;
    }

    public void setAddress3(String address3) {
        this.address3 = address3;
    }

    public String getCity() {
        return this.city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getCountry() {
        return this.country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPostcode() {
        return this.postcode;
    }

    public void setPostcode(String postcode) {
        this.postcode = postcode;
    }

    public String getState() {
        return this.state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public String getTelephoneno() {
        return telephoneno;
    }

    public void setTelephoneno(String telephoneno) {
        this.telephoneno = telephoneno;
    }

    public String getMobileno() {
        return mobileno;
    }

    public void setMobileno(String mobileno) {
        this.mobileno = mobileno;
    }

    public List<Collection> getCollections() {
        return this.collections;
    }

    public void setCollections(List<Collection> collections) {
        this.collections = collections;
    }

    public Collection addCollection(Collection collection) {
        getCollections().add(collection);
        collection.setAddress(this);

        return collection;
    }

    public Collection removeCollection(Collection collection) {
        getCollections().remove(collection);
        collection.setAddress(null);

        return collection;
    }

    public List<Delivery> getDeliveries() {
        return this.deliveries;
    }

    public void setDeliveries(List<Delivery> deliveries) {
        this.deliveries = deliveries;
    }

    public Delivery addDelivery(Delivery delivery) {
        getDeliveries().add(delivery);
        delivery.setAddress(this);

        return delivery;
    }

    public Delivery removeDelivery(Delivery delivery) {
        getDeliveries().remove(delivery);
        delivery.setAddress(null);

        return delivery;
    }


}

但我想知道是否有更好的方法来做到这一点。是否有任何东西可以用来传递新的

地址

对象，以检查数据库中是否存在相同的

地址

编辑

根据Manish的回答，我的理解如下：

1> 创建接口

ExtendedJpaRepository

，如回答中所述

2> 为此接口创建实现类，如下所示（参考：）

公共类MyRepositoryImpl
扩展SimpleParepository实现MyRepository{
列表findByExample（T示例）{
//QueryByExample的EclipseLink实现
}
}

3> 然后，对于每个存储库接口，扩展

ExtendedJpaRepository

。这将使

findByExample

在每个存储库中都可以随时使用

4> 如的步骤4所述，创建自定义存储库工厂以替换默认的RepositoryFactoryBean

---

5> 声明自定义工厂的bean。（的第5步）

您要查找的内容被称为

示例查询

。如中所述，JPA2.0考虑了此功能，但未包含在最终版本中。这篇文章还解释了大多数JPA提供商都具有实现此功能所必需的功能

您可以创建定制的JPA存储库实现，以提供现成的功能。有关详情，请参阅

一个起点是创建一个新接口，例如：

public interface ExtendedJpaRepository<T, ID extends Serializable>
    extends JpaRepository<T, ID> {
  List<T> findByExample(T example);
}

公共接口扩展jparepository
扩展JPA假设{
列表findByExample（T示例）；
}

然后，为这个接口插入一个使用底层JPA提供程序的实现。最后，将自定义实现配置为用于所有存储库接口

---

之后，您应该能够调用

addressRepository.findByExample（address）

，前提是

addressRepository

ExtendedJpaRepository

您可以使用Spring数据提供的现成规范。并且能够使用criteria API以编程方式构建查询。为了支持规范，您可以使用JpaSpecificationExecutor接口扩展存储库接口

public interface CustomerRepository extends SimpleJpaRepository<T, ID>, JpaSpecificationExecutor {

}

公共接口CustomerRepository扩展了SimpleParepository，JpaSpecificationExecutor{
}

附加接口（JpaSpecificationExecutor）包含允许您以多种方式执行规范的方法

例如，findAll方法将返回与规范匹配的所有实体：

List<T> findAll(Specification<T> spec);

清单findAll（规范规范）；

规范界面如下：

public interface Specification<T> {
  Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}

公共接口规范{
谓词toPredicate（根根、标准查询、，
标准生成器）；
}

好的，那么典型的用例是什么？规范可以很容易地用于在实体之上构建一组可扩展的谓词，然后可以将这些谓词与JpaRepository组合使用，而无需为每个需要的组合声明查询（方法）。下面是一个例子： 例2.15。客户规格

public class CustomerSpecs {

  public static Specification<Customer> isLongTermCustomer() {
    return new Specification<Customer>() {
      public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query,
            CriteriaBuilder builder) {

         LocalDate date = new LocalDate().minusYears(2);
         return builder.lessThan(root.get('dateField'), date);
      }
    };
  }

  public static Specification<Customer> hasSalesOfMoreThan(MontaryAmount value) {
    return new Specification<Customer>() {
      public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder) {

         // build query here
      }
    };
  }
}

公共类客户规范{
公共静态规范isLongTermCustomer（）{
返回新规范（）{
公共谓词toPredicate（根根、标准查询、，
标准生成器（生成器）{
LocalDate日期=新的LocalDate（）.minusYears（2）；
返回builder.lessThan（root.get（'dateField'），date）；
}
};
}
公共静态规范hasSalesOfMoreThan（MontaryAmount值）{
返回新规范（）{
公共谓词toPredicate（根根、标准查询、，
标准生成器（生成器）{
//在此处生成查询
}
};
}
}

您在业务需求抽象级别上表达了一些标准，并创建了可执行规范。因此，客户机可能会使用如下规范： List customers=customerRepository.findAll（isLongTermCustomer（））

您还可以结合规范 例2.17。组合规格

MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
List<Customer> customers = customerRepository.findAll(
  where(isLongTermCustomer()).or(hasSalesOfMoreThan(amount)));

MonetaryAmount amount=新的MonetaryAmount（200.0，货币.美元）；
列出客户=customerRepository.findAll(
其中（isLongTermCustomer（））或（HassalesOfMore（amount））；

正如您所看到的，规范提供了一些用于链接的粘合代码方法 和组合规格。因此，扩展数据访问层是非常必要的 只是创建新规范和实现的问题 将它们与现有的结合起来

您可以创建复杂的规范，下面是一个示例

public class WorkInProgressSpecification {

    public static Specification<WorkInProgress> findByCriteria(final SearchCriteria searchCriteria){

        return new Specification<WorkInProgress>() {

            @Override
            public Predicate toPredicate(Root<WorkInProgress> root,
                    CriteriaQuery<?> query, CriteriaBuilder cb) {

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

                if(searchCriteria.getView()!=null && !searchCriteria.getView().isEmpty()){
                    predicates.add(cb.equal(root.get("viewType"), searchCriteria.getView()));
                }if(searchCriteria.getFeature()!=null && !searchCriteria.getFeature().isEmpty()){
                    predicates.add(cb.equal(root.get("title"), searchCriteria.getFeature()));
                }if(searchCriteria.getEpic()!=null && !searchCriteria.getEpic().isEmpty()){
                    predicates.add(cb.equal(root.get("epic"), searchCriteria.getEpic()));
                }if( searchCriteria.getPerformingGroup()!=null && !searchCriteria.getPerformingGroup().isEmpty()){
                    predicates.add(cb.equal(root.get("performingGroup"), searchCriteria.getPerformingGroup()));
                }if(searchCriteria.getPlannedStartDate()!=null){
                        System.out.println("searchCriteria.getPlannedStartDate():" + searchCriteria.getPlannedStartDate());
                    predicates.add(cb.greaterThanOrEqualTo(root.<Date>get("plndStartDate"), searchCriteria.getPlannedStartDate()));
                }if(searchCriteria.getPlannedCompletionDate()!=null){
                    predicates.add(cb.lessThanOrEqualTo(root.<Date>get("plndComplDate"), searchCriteria.getPlannedCompletionDate()));
                }if(searchCriteria.getTeam()!=null && !searchCriteria.getTeam().isEmpty()){
                    predicates.add(cb.equal(root.get("agileTeam"), searchCriteria.getTeam()));
                }

                return cb.and(predicates.toArray(new Predicate[]{}));
            }
        };
    }
}

公共类工作进程规范{
公共静态规范findByCriteria（最终搜索条件SearchCriteria）{
返回新规范（）{
@凌驾
公共谓词toPredicate（根，
CriteriaQuery查询，CriteriaBuilder（cb）{
列表谓词=新的ArrayList（）；
if（searchCriteria.getView（）！=null&！searchCriteria.getView（）.isEmpty（））{
add（cb.equal（root.get（“viewType”）、searchCriteria.getView（））；
}if（searchCriteria.getFeature（）！=null&！searchCriteria.getFeature（）.isEmpty（））{
add（cb.equal（root.get（“title”）、searchCriteria.getFeature（））；
}if（searchCriteria.getEpic（）！=null&！searchCriteria.getEpic（）.isEmpty（））{
add（cb.equal（root.get（“epic”）、searchCriteria.getEpic（））；
}if（searchCriteria.getPerformingGroup（）！=nu
MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
List<Customer> customers = customerRepository.findAll(
  where(isLongTermCustomer()).or(hasSalesOfMoreThan(amount)));

public class WorkInProgressSpecification {

    public static Specification<WorkInProgress> findByCriteria(final SearchCriteria searchCriteria){

        return new Specification<WorkInProgress>() {

            @Override
            public Predicate toPredicate(Root<WorkInProgress> root,
                    CriteriaQuery<?> query, CriteriaBuilder cb) {

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

                if(searchCriteria.getView()!=null && !searchCriteria.getView().isEmpty()){
                    predicates.add(cb.equal(root.get("viewType"), searchCriteria.getView()));
                }if(searchCriteria.getFeature()!=null && !searchCriteria.getFeature().isEmpty()){
                    predicates.add(cb.equal(root.get("title"), searchCriteria.getFeature()));
                }if(searchCriteria.getEpic()!=null && !searchCriteria.getEpic().isEmpty()){
                    predicates.add(cb.equal(root.get("epic"), searchCriteria.getEpic()));
                }if( searchCriteria.getPerformingGroup()!=null && !searchCriteria.getPerformingGroup().isEmpty()){
                    predicates.add(cb.equal(root.get("performingGroup"), searchCriteria.getPerformingGroup()));
                }if(searchCriteria.getPlannedStartDate()!=null){
                        System.out.println("searchCriteria.getPlannedStartDate():" + searchCriteria.getPlannedStartDate());
                    predicates.add(cb.greaterThanOrEqualTo(root.<Date>get("plndStartDate"), searchCriteria.getPlannedStartDate()));
                }if(searchCriteria.getPlannedCompletionDate()!=null){
                    predicates.add(cb.lessThanOrEqualTo(root.<Date>get("plndComplDate"), searchCriteria.getPlannedCompletionDate()));
                }if(searchCriteria.getTeam()!=null && !searchCriteria.getTeam().isEmpty()){
                    predicates.add(cb.equal(root.get("agileTeam"), searchCriteria.getTeam()));
                }

                return cb.and(predicates.toArray(new Predicate[]{}));
            }
        };
    }
}