智能商贸系统1

最新推荐文章于 2022-07-08 13:54:49 发布

梦里花落知多少、

最新推荐文章于 2022-07-08 13:54:49 发布

阅读量245

点赞数

文章标签： SpringDataJpa

本文链接：https://blog.csdn.net/primarykey123/article/details/99618358

版权

集成Spring +SpringMVC+SpringDataJpa
1.1在pom.xml中引入相应的依赖jar包


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>cn.itsource</groupId>
  <artifactId>yxb</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
    <org.hibernate.version>4.3.8.Final</org.hibernate.version>
    <spring-data-jpa.version>1.9.0.RELEASE</spring-data-jpa.version>
    <com.fasterxml.jackson.version>2.5.0</com.fasterxml.jackson.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>

org.apache.shiro shiro-all 1.4.0 pom org.apache.shiro shiro-spring 1.4.0 org.apache.poi poi 3.11 org.apache.poi poi-ooxml 3.11 net.coobird thumbnailator 0.4.6 quartz quartz 1.5.2 javax.mail mail 1.4.1 yxb org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 org.mortbay.jetty jetty-maven-plugin 8.1.15.v20140411 9966 foo / 注意：上面的jar可能本地仓库中没有，先联网，在添加依赖，就可以自动下载缺失的jar包

1.2配置applicationContext.xml文件
下面红色部分是新增的

<?xml version="1.0" encoding="UTF-8"?>

<!-- 扫描service部分的包 -->
<context:component-scan base-package="cn.itsource.pss.service" />
<context:property-placeholder location="classpath:jdbc.properties" />

<!-- 配置连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <!--连接数据4个属性 -->
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <!--maxActive: 最大连接数量 -->
    <property name="maxActive" value="150" />
    <!--minIdle: 最小空闲连接 -->
    <property name="minIdle" value="5" />
    <!--maxIdle: 最大空闲连接 -->
    <property name="maxIdle" value="20" />
    <!--initialSize: 初始化连接 -->
    <property name="initialSize" value="30" />
    <!-- 用来配置数据库断开后自动连接的 -->
    <!-- 连接被泄露时是否打印 -->
    <property name="logAbandoned" value="true" />
    <!--removeAbandoned: 是否自动回收超时连接 -->
    <property name="removeAbandoned" value="true" />
    <!--removeAbandonedTimeout: 超时时间(以秒数为单位) -->
    <property name="removeAbandonedTimeout" value="10" />
    <!--maxWait: 超时等待时间以毫秒为单位 1000等于60秒 -->
    <property name="maxWait" value="1000" />
    <!-- 在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位. -->
    <property name="timeBetweenEvictionRunsMillis" value="10000" />
    <!-- 在每次空闲连接回收器线程(如果有)运行时检查的连接数量 -->
    <property name="numTestsPerEvictionRun" value="10" />
    <!-- 1000 * 60 * 30 连接在池中保持空闲而不被空闲连接回收器线程 -->
    <property name="minEvictableIdleTimeMillis" value="10000" />
    <property name="validationQuery" value="SELECT NOW() FROM DUAL" />
</bean>

<!-- 集成hibernate的jpa功能 -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!--待扫描的实体类包，不再需要persistence.xml了 -->
    <property name="packagesToScan" value="cn.itsource.aisell.domain" />
    <!-- 3.配置JPA的实现 -->
    <!-- private JpaVendorAdapter jpaVendorAdapter; -->
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <!-- org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter -->
            <!-- private boolean showSql = false;是否显示sql语句 -->
            <property name="showSql" value="true" />
            <!-- private boolean generateDdl = false;是否建表 -->
            <property name="generateDdl" value="false" />
            <!-- private String databasePlatform;原来方言 -->
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
        </bean>
    </property>
</bean>

<!-- Jpa 事务配置 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 注解声明式事务管理 -->
<tx:annotation-driven />

<!-- Spring Data Jpa配置 ********************************************-->
<!-- base-package:扫描的包 -->
<jpa:repositories base-package="cn.itsource.pss.repository" transaction-manager-ref="transactionManager"
                  entity-manager-factory-ref="entityManagerFactory" />

1.3每一个domain类都有主键id 那么我们抽取这个共同属性作为父类 @MappedSuperclass 这个注解表示这是父类，不持久化到表中 public class BaseDomain { @Id @GeneratedValue public Long id;

    public Long getId() {
        return id;
    }

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

1.4 创建子类【Employee】今天围绕这个表做相应的功能

@Entity
public class Employee extends BaseDomain{
    private String username;
    private String email;
    private String headImage;
    private Integer age;
public String getUsername() {
    return username;
}

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

public String getEmail() {
    return email;
}

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

public String getHeadImage() {
    return headImage;
}

public void setHeadImage(String headImage) {
    this.headImage = headImage;
}

public Integer getAge() {
    return age;
}

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

}

1.5 实现JpaRepository接口，测试是否集成到它的功能
JpaRepository<1v,2v>
1v:代表你要操作的是哪一个domain对象
2v:这个domain对象的主键的类型

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}
测试是否实现功能

package cn.itsource._01TestCRUD;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeTest {
    /*
    * 测试简单的crud
    @Autowired
    private EmployeeRepository employeeRepository;
    @Test
    public void testFind1(){
        //查询全部
        List<Employee> list = employeeRepository.findAll();
        list.forEach(e -> System.out.println(e));
    };

//查询一条，根据id
@Test
public void testFindOne(){
    Employee one = employeeRepository.findOne(1L);
    System.out.println(one);
};
//添加数据
@Test
public void testSave(){
    Employee employee = new Employee();
    employee.setUsername("二狗");
    employee.setAge(16);
    employee.setEmail("999@666.com");
    employee.setHeadImage("99999999999");
    employeeRepository.save(employee);
};
//修改操作
@Test
public void testUpdate(){
    Employee employee = new Employee();
    employee.setId(274L);
    employee.setUsername("大狗");
    employee.setAge(16);
    employee.setEmail("999@666.com");
    employee.setHeadImage("99999999999");
    employeeRepository.save(employee);
};
//删除操作 1.一次删一条
@Test
public void testDel(){
    employeeRepository.delete(274L);
};

//一次删除多条【deleteInBatch批量删除】
@Test
public void testDel2(){
    //先查询几条数据 delete from Employee where id=? or id=? or id=?   效率较高
    List<Long> list = Arrays.asList(275L, 276L,277L);
    List<Employee> list1 = employeeRepository.findAll(list);
    //list1.forEach(employee -> System.out.println(employee));
    employeeRepository.deleteInBatch(list1);
};

//一次删除多条【delete(list1);】  发出多条sql 效率较低
@Test
public void testDel3(){
    //先查询几条数据 delete from Employee where id=? or id=? or id=?   效率较高
    List<Long> list = Arrays.asList(278L,279L);
    List<Employee> list1 = employeeRepository.findAll(list);
    employeeRepository.delete(list1);
};
//查询数据总条数
@Test
public void testCount(){
    System.out.println(employeeRepository.count());
};

}
以上说明功能全部实现
2. SpringDataJpa的认识与使用
2.1 ORM框架

MyBatis:Apache的一个开源项目(咱们第三个项目使用的框架)，上手简单，开发灵活，现在市场占有率高; 但是开发时工作量比较大，需要做很多配置，并且自己要写SQL语句。
Hibernate:一个开放源代码的对象关系映射框架，是完全面向对象的。可以使用面向对象的思路来完成数据库操作。 Hibernate是完备的ORM框架(咱们之前学习JPA，底层就是使用Hibernate完成的)。

2.2 SpringDataJpa 简述
它是JPA规范的再次封装抽象，底层还是使用了Hibernate的JPA技术实现，引用JPQL的查询语句，是属于Spring的生成体系中的一部分。
SpringDataJpa使用起来比较方便，加快了开发的效果，使开发人员不需要关心和配置更多的东西。
SpringDataJpa上手简单，开发效率高，对对象的支持非常好，还十分的灵活。

Spring Data项目是从2010年开发发展起来的，是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。 Spring Data 包含多个子项目：
Commons - 提供共享的基础框架，适合各个子项目使用，支持跨数据库持久化
JPA - 简化创建 JPA 数据访问层和跨存储的持久层功能
Hadoop - 基于 Spring 的 Hadoop 作业配置和一个 POJO 编程模型的 MapReduce 作业
Key-Value - 集成了 Redis 和 Riak ，提供多个常用场景下的简单封装
Document - 集成文档数据库：CouchDB 和 MongoDB 并提供基本的配置映射和资料库支持
Graph - 集成 Neo4j 提供强大的基于 POJO 的编程模型
Graph Roo AddOn - Roo support for Neo4j
JDBC Extensions - 支持 Oracle RAD、高级队列和高级数据类型
Mapping - 基于 Grails 的提供对象映射框架，支持不同的数据库
Examples - 示例程序、文档和图数据库
Guidance - 高级文档
2.3 SpringData的结构图

2.4 JpaRepository的分页与排序功能
先抽取一个Spring测试的父类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class BaseTest {
}

测试JpaRepository的分页排序功能

public class PageAndSort extends BaseTest {
    @Autowired
    private EmployeeRepository employeeRepository;

//测试普通分页
@Test
public void testPage(){
    //创建分页对象【可以有三个参数】 new PageRequest(int currentpage,int pagesize,sort );
    PageRequest pageRequest = new PageRequest(13,10);
    //下面返回的Page 对象实现了Iterator 可以遍历
    Page<Employee> page = employeeRepository.findAll(pageRequest);
    System.out.println(page.getTotalElements());  //总数据条数
    System.out.println(page.getTotalPages());       //总页数
    System.out.println(page.getContent());          //当前页的数据内容
    System.out.println(page.getNumber());           //当前是第几页
    System.out.println(page.getNumberOfElements()); //当前页的数据条数
    System.out.println(page.getSize());     //每页的数据条数
    System.out.println("-----------------------------------------------");
    page.forEach(employee -> System.out.println(employee));
};

//测试普通排序
@Test
public void testSort(){
    //创建一个sort对象 Sort(Sort.Direction direction, String...）  第一个参数，排序类型【升序，降序】，第二个参数按**排序
    Sort sort = new Sort(Sort.Direction.DESC,"age");
    List<Employee> list = employeeRepository.findAll(sort);
    list.forEach(employee -> System.out.println(employee));
};

//分页和排序同时完成
@Test
public void testPageAndSort(){
    //排序对象
    Sort sort = new Sort(Sort.Direction.DESC,"age","id");
    //创建分页对象
    PageRequest pageRequest = new PageRequest(0, 5, sort);
    Page<Employee> page = employeeRepository.findAll(pageRequest);
    page.forEach(employee -> System.out.println(employee));
};

JpaRepository的带条件查询

//添加查询条件  1.根据名称查询
List<Employee>findByUsername(String username);
//2.根据名称模糊查询
List<Employee>findByUsernameLike(String username);
//3.按照年龄在A 与B之间 的员工
List<Employee>findByAgeBetween(int a,int b);
//4.查询年id 小于5的 员工
List<Employee>findByIdLessThan(Long id);

JpaRepository的@Query(jpql查询)  和@Query(原生sql查询)

//@Query注解查询 返回值 +  方法名 :拿到一个员工(它的Id是所有员工最大的)
    //@Query 后面写jpql
    @Query("select  e from Employee  e where e.id = (select max(o.id) from Employee  o) ")
    Employee query1();

//@Query后面写原生sql 查询
@Query(value = "select * from employee where age <30",nativeQuery =true)
List<Employee> query2();

//原生sql查询总条数
@Query(value = "select count(*) from employee ",nativeQuery =true)
Long query3();

JpaSpecificationExecutor的认识与使用
我们要使用这个接口中的方法,首先让我们的接口也去继承这个接口

Public interface Employee Repository extends JpaRepository<Employee,Long> ,JpaSpecificationExecutor {
}

3.1参数类型跟意义
* Root root 根对象，
* CriteriaQuery<?> cq 查询哪些字段，排序是什么(主要是把多个查询的条件连系起来)
* CriteriaBuilder cb 生成一个查询条件，每一个查询条件都是什么方式
* Predicate 查询条件语句
*
* EQ 就是 EQUAL等于
* NE就是 NOT EQUAL不等于
* GT 就是 GREATER THAN大于　
* LT 就是 LESS THAN小于
* GE 就是 GREATER THAN OR EQUAL 大于等于
* LE 就是 LESS THAN OR EQUAL 小于等于
*/
3.2使用它们的实现类完成CRUD功能 + 分页排序功能

public class JpaSpec extends BaseTest {
@Autowired
private EmployeeRepository1 employeeRepository1;

//测试JpaSpec的单条件查询
@Test
public void testJpaSpec(){
    List<Employee> list = employeeRepository1.findAll(new Specification<Employee>() {
        @Override
        public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
            Path path = root.get("username");  //拿到要做查询的字段
            Predicate p = cb.like(path, "%1%");//like代表做模糊查询，后面就是它的条件值
            return p;
        }
    });
    list.forEach(employee -> System.out.println(employee));

};

//测试JpaSpec的多条件查询
@Test
public void testJpaSpec2(){
    List<Employee> list = employeeRepository1.findAll(new Specification<Employee>() {
        @Override
        public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
            Path path = root.get("username");  //拿到要做查询的字段
            Path<Integer> path1 = root.get("age"); //获取第二个字段
            Predicate p1 = cb.like(path, "%d%");//like代表做模糊查询，后面就是它的条件值
            Predicate p2 = cb.gt(path1,300);  //给第二字段设置条件
            Predicate predicate = cb.and(p1, p2);
            return predicate;

        }
    });
    list.forEach(employee -> System.out.println(employee));
};

//JpaSpec的多条件查询+分页+排序
@Test
public void testJpaSpec3(){
    Specification spec = new Specification<Employee>() {
        @Override
        public Predicate toPredicate(Root root, CriteriaQuery cq, CriteriaBuilder cb) {
            //创建排序对象
            Sort sort = new Sort(Sort.Direction.DESC, "age");
            //创建分页对象
            PageRequest pageRequest = new PageRequest(0, 5, sort);

            Path path = root.get("username");  //拿到要做查询的字段
            Path<Integer> path1 = root.get("age"); //获取第二个字段
            Predicate p1 = cb.like(path, "%1%");//like代表做模糊查询，后面就是它的条件值
            Predicate p2 = cb.gt(path1,25);  //给第二字段设置条件
            //把两个查询条件放到query对象中去(条件使用where)
            CriteriaQuery where = cq.where(p1,p2);

            return where.getRestriction();
        }
    };
    //创建排序对象
    Sort sort = new Sort(Sort.Direction.DESC, "age");
    //创建分页对象
    PageRequest pageRequest = new PageRequest(0, 5, sort);
    Page page = employeeRepository1.findAll(spec, pageRequest);

    page.forEach(employee -> System.out.println(employee));
};

}

3.3 JpaSpecificationExecutor 功能的扩展 jpa-spec插件
3.3.1. 先导入相应的jar包

@Test
		public void testSpecFind01() {
		    Specification<Employee> spec = Specifications.<Employee>and().like("username", "%1%").build();
		    List<Employee> emps = employeeRepository.findAll(spec);
		    for (Employee emp : emps) {
		        System.out.println(emp);
		    }
		}

3.3.2 测试扩展功能的使用

public class JpaSpec1 extends BaseTest {
    @Autowired
    private EmployeeRepository1 employeeRepository1;
    //测试 JpaSpec插件的使用 1.多条件查询 查询名字种有b，年龄大于300 的数据
    @Test
    public void testJpaSpec1(){
        //模拟设置查询条件
        Employee employee = new Employee();
        employee.setUsername("%1%");
        employee.setAge(25);
        Specification<Employee> spec =  Specifications.<Employee>and()
                .like(StringUtils.isNotBlank(employee.getUsername()),"username", employee.getUsername())
                .gt(employee.getAge()!= null,"age",employee.getAge())
                .build();
        List<Employee> list = employeeRepository1.findAll(spec);

    list.forEach(e -> System.out.println(e));

};

//测试 JpaSpec插件的使用 2.多条件查询 查询名字种有a，年龄小于26 的数据  分页+ 排序
@Test
public void testJpaSpec2(){
    //模拟设置查询条件
    Employee employee = new Employee();
    employee.setUsername("%a%");
    employee.setAge(26);
    Specification<Employee> spec =  Specifications.<Employee>and()
            .like(StringUtils.isNotBlank(employee.getUsername()),"username", employee.getUsername())
            .lt(employee.getAge()!= null,"age",employee.getAge())
            .build();
    //创建排序对象【按照id升序】
    Sort sort = new Sort(Sort.Direction.ASC, "id");
    //创建分页对象
    PageRequest pageRequest = new PageRequest(0, 6, sort);

    Page<Employee> page = employeeRepository1.findAll(spec, pageRequest);

    page.forEach(e -> System.out.println(e));

}
4 为了少写代码，抽取一个类作为工具类
4.1 BaseQuery 类
将查询，分页排序的方法抽取到这个工具类中
* */
public abstract class BaseQuery {
//定义分页相关的字段当前页默认1
private Integer currentPage = 1;
//每页的数据条数，默认 5
private Integer pageSize = 5;
//定义排序相关的字段通过什么排序
private String OrderByNname;
//排序的方式默认为升序
private String OrderByType = “ASC”;

    //单独定义一个获取分页开始页的方法
    public  Integer JpaPage(){
        return currentPage - 1;
    }
    public Integer getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(Integer currentPage) {
        this.currentPage = currentPage;
    }

    public Integer getPageSize() {
        return pageSize;
    }

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

    public String getOrderByNname() {
        return OrderByNname;
    }

    public void setOrderByNname(String orderByNname) {
        OrderByNname = orderByNname;
    }

    public String getOrderByType() {
        return OrderByType;
    }

    public void setOrderByType(String orderByType) {
        OrderByType = orderByType;
    }

//定义获取Specification的【查询条件】方法 因为每个表的条件是不一样的，所以只能是抽象方法
public abstract  Specification getSpec();

//定义获取分页对象的方法【排序包含在其中】
public PageRequest creatPage(){
    //先获取排序方式
    Sort sort = null;
        if(StringUtils.isNotBlank(OrderByNname)&&"ASC".equals(OrderByType)){
            sort = new Sort(Sort.Direction.ASC,OrderByNname);
        }else if (StringUtils.isNotBlank(OrderByNname)&&"DESC".equals(OrderByType)){
            sort = new Sort(Sort.Direction.DESC,OrderByNname);
        }
    //获取分页对象
    PageRequest pageRequest = new PageRequest(JpaPage(), pageSize, sort);
    return pageRequest;
}

}
4.2 EmployeeQuery 类【因为每张表的字段不同】
//抽取一个Employee表查询方法的工具类
public class EmployeeQuery extends BaseQuery{
//比如高级搜索有下面三中方式
private String username;
private Integer age;
private String email;

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;
}

public String getEmail() {
    return email;
}

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

@Override
public Specification getSpec() {
    Specification<Employee> spec =  Specifications.<Employee>and()
            .like(StringUtils.isNotBlank(username),"username", username)
            .gt(age!= null,"age",age)
            .build();
    return spec;
}

}
4.3测试工具类的功能
public class JpaSpec2 extends BaseTest {

@Autowired
private EmployeeRepository1 employeeRepository1;
@Test
public void testJpaSpec2(){
    //测试抽取后的EmployeeQuery
    EmployeeQuery employeeQuery = new EmployeeQuery();
	设置查询条件
    //employeeQuery.setAge(24);
    employeeQuery.setUsername("%d%");
	设置排序条件
    employeeQuery.setOrderByNname("age");
    employeeQuery.setOrderByType("DESC");
   设置分页条件

employeeQuery.setPageSize(10);
PageRequest pageRequest = employeeQuery.creatPage();
//开始查询
Page page = employeeRepository1.findAll(employeeQuery.getSpec(), pageRequest);
page.forEach(e-> System.out.println(e));

};

}

梦里花落知多少、

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
智能商贸系统1

集成Spring +SpringMVC+SpringDataJpa1.1在pom.xml中引入相应的依赖jar包<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/20...
复制链接

扫一扫