SpringDataJpa实现

最新推荐文章于 2024-07-24 14:56:22 发布

qq_43199561

最新推荐文章于 2024-07-24 14:56:22 发布

阅读量229

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_43199561/article/details/105670345

版权

SpringDataJpa
SpringDataJpa是JPA规范的再次封装，在使用时需要先集成JPA然后再集成SpringDataJpa，底层还是使用Hibernate的JPA技术实现，引用JPQL查询语句，简化JPA繁琐的操作
SpringDataJPA将JPA的方法名做了修改，写dao层是只需要写接口，不需要写实现类
SpringDataJpa入门案例
1、创建项目+导包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <org.springframework.version>4.3.7.RELEASE</org.springframework.version>
    <org.hibernate.version>4.3.8.Final</org.hibernate.version>
    <com.fasterxml.jackson.version>2.8.7</com.fasterxml.jackson.version>
    <spring-data-jpa.version>1.9.0.RELEASE</spring-data-jpa.version>
    <org.slf4j.version>1.6.1</org.slf4j.version>
  </properties>

  <dependencies>
    <!-- Spring的支持包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${org.springframework.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- 引入web前端的支持 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${org.springframework.version}</version>
    </dependency>
    <!-- SpringMCV上传需要用到io包-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.3.2</version>
    </dependency>
    <!-- 文件上传用到的包 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- SpringMVC的json支持包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${com.fasterxml.jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${com.fasterxml.jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${com.fasterxml.jackson.version}</version>
    </dependency>
    <!-- hibernate的支持包 -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${org.hibernate.version}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>${org.hibernate.version}</version>
    </dependency>
    <!-- SpringData的支持包 -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>${spring-data-jpa.version}</version>
    </dependency>
    <!-- SpringData的擴展包 -->
    <dependency>
      <groupId>com.github.wenhao</groupId>
      <artifactId>jpa-spec</artifactId>
      <version>3.1.1</version>
      <!-- 把所有的依賴都去掉 -->
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>

    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.5</version>
    </dependency>
    <!-- 測試包 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <!-- 这个scope 只能作用在编译和测试时，同时没有传递性。表示在运行的时候不添加此jar文件 -->
      <scope>provided</scope>
    </dependency>
    <!-- 日志文件 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${org.slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${org.slf4j.version}</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.14</version>
    </dependency>
    <!-- 代码生成器模版技术 -->
    <dependency>
      <groupId>org.apache.velocity</groupId>
      <artifactId>velocity</artifactId>
      <version>1.6</version>
    </dependency>
    <!-- shiro的支持包 -->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-all</artifactId>
      <version>1.4.0</version>
      <type>pom</type>
    </dependency>
    <!-- shiro与Spring的集成包 -->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring</artifactId>
      <version>1.4.0</version>
    </dependency>
    <!-- poi支持的jar包 -->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.11</version>
    </dependency>
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml</artifactId>
      <version>3.11</version>
    </dependency>
    <!-- 图片压缩功能 -->
    <!-- 缩略图 -->
    <dependency>
      <groupId>net.coobird</groupId>
      <artifactId>thumbnailator</artifactId>
      <version>0.4.6</version>
    </dependency>
    <!-- 定时调度 -->
    <dependency>
      <groupId>quartz</groupId>
      <artifactId>quartz</artifactId>
      <version>1.5.2</version>
    </dependency>
    <!-- 邮件支持 -->
    <dependency>
      <groupId>javax.mail</groupId>
      <artifactId>mail</artifactId>
      <version>1.4.1</version>
    </dependency>
  </dependencies>

2、集成jpa：spring.xml、jdbc.properties
3、集成SpringDataJpa配置：jpa:repositories,引用entityMagmentFactory、transactionManagment

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jps="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--扫描包-->
    <context:component-scan base-package=""/>

    <!--数据库连接池-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--集成JPA-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--引用数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置domain-->
        <property name="packagesToScan" value=" "/>
        <!--JPA实现厂商-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--是否自动建表-->
                <property name="generateDdl" value="false"/>
                <!--是否显示Sql-->
                <property name="showSql" value="true"/>
                <!--方言-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
            </bean>
        </property>
    </bean>
    <!--事务管理-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <jps:repositories base-package=" "
        entity-manager-factory-ref="entityManagerFactory"
        transaction-manager-ref="transactionManager"
        factory-class="cn.yinsh.ibs.utils.BaseRepositoryFactoryBean"
    />
</beans>

4、编写domain实体类&接口：
4.1.导入sql文件
4.2.写domain实体类：员工&部门entity,table,id,GenerateValue、解决serilalizible错误
4.3.写Dao层接口
5、接口继承JpaRepository：两个泛型：第一个为domain实体类的类型，第二个为domain实体类主键的类型
测试增删改查&分页&排序
6、SpringDataJpa的当前页面是从0开始的

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class _01_entryTest {
    @Autowired
    private IEmployeeRepository employeeRepository;


    @Test
    public void testFindOne() throws Exception{
        Employee employee = employeeRepository.findOne(66L);
        System.out.println(employee);
    }

    @Test
    public void testFindAll() throws Exception{
        List<Employee> list = employeeRepository.findAll();
        list.forEach(employee -> System.out.println(employee));
    }

    @Test
    public void testDelete() throws Exception{
        employeeRepository.delete(174L);
    }

    @Test
    public void testAdd() throws Exception{
        Employee employee = new Employee();
        employee.setUsername("admin1018");
        employee.setPassword("admin1018");
        employee.setEmail("admin1018@qq.com");
        employee.setAge(66);
        employeeRepository.save(employee);
    }

    @Test
    public void testUpdate() throws Exception{
        Employee employee = employeeRepository.findOne(274L);
        employee.setAge(77);
        employee.setUsername("admin1229");
        employee.setPassword("admin1229");
        employeeRepository.save(employee);
    }


    /*分页*/
    @Test
    public void testFindByPage() throws Exception{
        Pageable pageable = new PageRequest(1,10);
        Page<Employee> page = employeeRepository.findAll(pageable);
        //当前页
        System.out.println(page.getNumber());
        //当前页显示的行数
        System.out.println(page.getSize());
        //总页数
        System.out.println(page.getTotalPages());
        //总数据
        System.out.println(page.getTotalElements());
        //当前页的总行数
        System.out.println(page.getNumberOfElements());
        List<Employee> content = page.getContent();
        content.forEach(employee -> System.out.println(employee));

    }
    //排序
    @Test
    public void testFindBySort() throws Exception{
        Sort.Order order = new Sort.Order(Sort.Direction.DESC,"age");
        Sort sort = new Sort(order);
        List<Employee> list = employeeRepository.findAll(sort);
        list.forEach(employee -> System.out.println(employee));
    }
    //分页&排序
    @Test
    public void testFindByPageAndSort() throws Exception{
        Sort.Order order = new Sort.Order(Sort.Direction.DESC,"age");
        Sort sort = new Sort(order);
        Pageable pageable = new PageRequest(0,10,sort);
        Page<Employee> page = employeeRepository.findAll(pageable);
        page.forEach(employee -> System.out.println(employee));
    }

    //简单查询
    @Test
    public void testFindByUsername() throws Exception{

        List<Employee> username = employeeRepository.findAllByUsernameLike("%admin1229%");
        username.forEach(employee -> System.out.println(employee));
    }

    @Test
    public void testFindByAge() throws Exception{
        List<Employee> allByAgeEquals = employeeRepository.findAllByAgeEquals(34);
        allByAgeEquals.forEach(employee -> System.out.println(employee));
    }

    @Test
    public void testFindUsername() throws Exception{
        List<Employee> username = employeeRepository.findUsername("%admin25%");
        username.forEach(employee -> System.out.println(employee));
    }

    @Test
    public void testFindSql() throws Exception{
        List<Employee> bySql = employeeRepository.findBySql("%admin25%");
        bySql.forEach(employee -> System.out.println(employee));
    }
}

JpaSpeciﬁcationExecutor

public interface IEmployeeRepository extends  JpaRepository<Employee,Long>,JpaSpecificationExecutor<Employee> { }

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.criteria.*;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class _02_specificationTest {
    @Autowired
    private IEmployeeRepository employeeRepository;

    //单条件查询
    @Test
    public void testFindByUsername() throws Exception{
        Specification<Employee> specification = new Specification<Employee>() {
            /**
             *
             * @param root:表示用来作为查询的字段
             * @param criteriaQuery:当具有多个条件时，使用AND来进行拼接
             * @param criteriaBuilder:拼接字段后面的条件运算符
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path username = root.get("username");
                Predicate predicate = criteriaBuilder.like(username, "%admin25%");
                return predicate;
            }
        };
        List<Employee> all = employeeRepository.findAll(specification);
        all.forEach(employee -> System.out.println(employee));
    }
    //多条件查询
    @Test
    public void testFindByUsernameAndAge() throws Exception{
        Specification<Employee> specification = new Specification<Employee>() {
            /**
             *
             * @param root:表示用来作为查询的字段
             * @param criteriaQuery:当具有多个条件时，使用AND来进行拼接
             * @param criteriaBuilder:拼接字段后面的条件运算符
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path username = root.get("username");
                Predicate predicate = criteriaBuilder.like(username, "%asdf23%");

                Path age = root.get("age");
                Predicate predicate1 = criteriaBuilder.ge(age, 31);

                CriteriaQuery<?> query = criteriaQuery.where(predicate, predicate1);

                return query.getRestriction();
            }
        };
        List<Employee> all = employeeRepository.findAll(specification);
        all.forEach(employee -> System.out.println(employee));
    }
    //分页&排序
    @Test
    public void testFindByPageAndSort() throws Exception{
        Sort.Order order = new Sort.Order(Sort.Direction.DESC,"age");
        Sort sort = new Sort(order);
        Pageable pageable = new PageRequest(0,10,sort);
        Specification<Employee> specification = new Specification<Employee>() {
            /**
             *
             * @param root:表示用来作为查询的字段
             * @param criteriaQuery:当具有多个条件时，使用AND来进行拼接
             * @param criteriaBuilder:拼接字段后面的条件运算符
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path username = root.get("username");
                Predicate predicate = criteriaBuilder.like(username, "%admin%");

                Path age = root.get("age");
                Predicate predicate1 = criteriaBuilder.ge(age, 31);

                CriteriaQuery<?> query = criteriaQuery.where(predicate, predicate1);

                return query.getRestriction();
            }
        };
        List<Employee> all = employeeRepository.findAll(specification);
        all.forEach(employee -> System.out.println(employee));
    }
}

文浩的扩展插件jpa-spec

import com.github.wenhao.jpa.Specifications;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class _03_speTest {
    @Autowired
    private IEmployeeRepository employeeRepository;


    @Test
    public void test() throws Exception{
        Sort.Order order = new Sort.Order(Sort.Direction.DESC,"age");
        Sort sort = new Sort(order);
        Pageable pageable = new PageRequest(0,10,sort);

        Specification<Employee> specification = Specifications.<Employee>and()
                .like("username","%admin%")
                .eq("age",34)
                .build();
        Page<Employee> page = employeeRepository.findAll(specification, pageable);
        page.forEach(employee -> System.out.println(employee));
    }
}

抽取BaseQuery

import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

public abstract class BaseQuery<T> {

    private Integer pageNum = 1;
    private Integer pageSize = 10;
    //默认以Id排序
    private String orderFiled = "id";
    //默认的排序方式
    private String orderType = "desc";


    public abstract Specification<T> getSpecification();
    public abstract Sort getSort();
    public abstract Pageable getPageable();

    public Integer getJpaPageNum() {
        return pageNum-1;
    }

    public void setPageNum(Integer pageNum) {
        this.pageNum = pageNum;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public String getOrderFiled() {
        return orderFiled;
    }

    public void setOrderFiled(String orderFiled) {
        this.orderFiled = orderFiled;
    }

    public String getOrderType() {
        return orderType;
    }

    public void setOrderType(String orderType) {
        this.orderType = orderType;
    }
}

EmployeeQuery

import com.github.wenhao.jpa.Specifications;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

public class EmployeeQuery extends BaseQuery{

    private String username;
    private Integer age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public Specification getSpecification() {
        Specification specification = Specifications.and()
                .like("username","%"+username+"%")
                .eq("age",age)
                .build();
        return specification;
    }

    @Override
    public Sort getSort() {
        Sort sort = null;
        //判断字符串是否为null和“”
        if (StringUtils.isNoneBlank(this.getOrderFiled())){
            Sort.Direction direction = Sort.Direction.ASC;
            if ("desc".equalsIgnoreCase(this.getOrderType())){
                direction = Sort.Direction.DESC;
            }
            Sort.Order order = new Sort.Order(direction, this.getOrderFiled());
            sort = new Sort(order);
        }
        return sort;
    }

    @Override
    public Pageable getPageable() {
        Pageable pageable = new PageRequest(this.getJpaPageNum(),this.getPageSize(),this.getSort());
        return pageable;
    }
}

自定义扩展
调用ﬁndAll方法的时候传入了两个参数，Speciﬁcation和Pageable对象，但是这两个参数来自于同一个EmployeeQuery对象身上，可以直接传一个参数。所以需要自定义扩展
步骤分析
① 自定义接口IBaseRepository继承 JpaRepository 和 JpaSpeciﬁcationExecutor
② 在自定义的接口 IBaseRepository 中去扩展方法
③ 自定义类 BaseRepositoryImpl 继承 SimpleJpaRepository 类，实现 IBaseRepository 接口，并且实IBaseRepository接口中扩展的抽象方法
④ SpringDataJpa 默认使用 SimpleJpaRepository 类来作为动态代理类的直接父类，这个我们需要通过配置来修改，改成使用 BaseRepositoryImpl 来作为动态代理类的直接父类
⑤ IEmployeeRepository 接口继承 IBaseRepository 接口
IBaseRepository接口

import cn.yinsh.ibs.query.BaseQuery;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

import java.io.Serializable;
import java.util.List;
@NoRepositoryBean
public interface IBaseRepository<T, ID extends Serializable> extends JpaRepository<T,ID>,JpaSpecificationExecutor<T> {
    //分页&高级查询&排序
    Page<T> findByQueryAndPage(BaseQuery<T> baseQuery);

    //高级查询&排序
    List<T> findByQuery(BaseQuery<T> baseQuery);

    //Jpql查询
    List findByJpql(String jpql,Object... value);
}

.BaseRepositoryImpl类

import cn.yinsh.ibs.query.BaseQuery;
import cn.yinsh.ibs.repository.IBaseRepository;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;

import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import java.io.Serializable;
import java.util.List;

public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T,ID> implements IBaseRepository<T,ID> {

    private EntityManager entityManager;

    public BaseRepositoryImpl(Class<T> domainClass, EntityManager entityManager) {
        super(domainClass, entityManager);
        this.entityManager = entityManager;
    }

    @Override
    public Page<T> findByQueryAndPage(BaseQuery<T> baseQuery) {
        return super.findAll(baseQuery.getSpecification(),baseQuery.getPageable());
    }

    @Override
    public List<T> findByQuery(BaseQuery<T> baseQuery) {
        return super.findAll(baseQuery.getSpecification(),baseQuery.getSort());
    }

    @Override
    public List<T> findByJpql(String jpql, Object... values) {
        Query query = entityManager.createQuery(jpql);
        //如果JPQL中有?占位符，则需要设置参数后才能查询
        if (values!=null && values.length>0){
            for (int i = 0;i< values.length;i++){
                query.setParameter(i+1,values[i]);
            }
        }
        return query.getResultList();
    }
}

.修改SpringDataJpa的默认配置
SpringDataJpa是默认使用SimpleJpaRepository来作为动态代理类的直接父类，虽然我们刚才写了BaseRepositoryImpl类，但是SpringDataJpa不知道，所以要通过配置文件告诉它。

import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.core.RepositoryInformation;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;

import javax.persistence.EntityManager;
import java.io.Serializable;

public class BaseRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extends Serializable> extends JpaRepositoryFactoryBean<T,S,ID> {

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
          return new MyRepositoryFactory<T,ID>(entityManager); //注：这里创建是我们的自定义类
    }

    //继承JpaRepositoryFactory后，把返回的对象修改成我们自己的实现
    private static  class MyRepositoryFactory<T,ID extends Serializable>   extends JpaRepositoryFactory{
        private final EntityManager entityManager;
        /**
         * Creates a new {@link JpaRepositoryFactory}.
         *
         * @param entityManager must not be {@literal null}
         */
        public MyRepositoryFactory(EntityManager entityManager) {
            super(entityManager);
            this.entityManager = entityManager;
        }
	   //这里返回最后的功能对象
        @Override
        protected Object getTargetRepository(RepositoryInformation information) {
            return new BaseRepositoryImpl<T,ID>((Class<T>)information.getDomainType(),entityManager);
        }
	   //确定功能对象的类型
        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return BaseRepositoryImpl.class;
        }
    }
}

修改SpringDataJpa的默认配置

<jps:repositories base-package="cn.yinsh.ibs.repository"
        entity-manager-factory-ref="entityManagerFactory"
        transaction-manager-ref="transactionManager"
        factory-class="cn.yinsh.ibs.utils.BaseRepositoryFactoryBean"/>

测试

import org.hibernate.annotations.SourceType;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class _05_IBaseRepositoryTest {
    @Autowired
    private IEmployeeRepository employeeRepository;

    public EmployeeQuery getEmployeeQuery(){
        EmployeeQuery employeeQuery = new EmployeeQuery();
        employeeQuery.setAge(25);
        employeeQuery.setUsername("admin");
        return employeeQuery;
    }

    @Test
    public void test() throws Exception{
        //方法参数为BaseQuery，调用时传入BaseQUery的子类对象
        Page<Employee> page = employeeRepository.findByQueryAndPage(getEmployeeQuery());
        page.forEach(employee -> System.out.println(employee));
    }

    @Test
    public void test01() throws Exception{
        List byQuery = employeeRepository.findByQuery(getEmployeeQuery());
        byQuery.forEach(employee-> System.out.println(employee));
    }

    @Test
    public void test2() throws Exception{
        String jpql = "select e from Employee e where e.username like ?1 and e.age>?2";
        List admin = employeeRepository.findByJpql(jpql, "admin", 25);
        admin.forEach(employee-> System.out.println(employee));
    }
}

注意点：
IBaseRepository接口中没有添加@NoRepositoryBean，运行报错：
java.lang.IllegalArgumentException: Not an managed type: class java.lang.Object 不是一个被JPA管理的类型
原因是没写那个注解，由于IBaseRepository接口中不能确定泛型的类型，所以它就默认使用Object 来代替那个泛型T

子接口要继承IBaseRepository，不要再去继承原先那两个接口了。
jpa:repositories标签上添加factory-class属性

qq_43199561

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringDataJpa实现

SpringDataJpaSpringDataJpa是JPA规范的再次封装，在使用时需要先集成JPA然后再集成SpringDataJpa，底层还是使用Hibernate的JPA技术实现，引用JPQL查询语句，简化JPA繁琐的操作SpringDataJPA将JPA的方法名做了修改，写dao层是只需要写接口，不需要写实现类SpringDataJpa入门案例1、创建项目+导包<prope...
复制链接

扫一扫