写作时间：2019-11-06
实现目标：Spring Data JPA入门
涉及知识：持久层框架

【思维导图】

【Spring Data JPA简介】

Spring Data JPA 是 spring data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。

【依赖与配置数据源】

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

server:
  port: 8080
  servlet:
    context-path: /
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
    username: root
    password: root
  jpa:
    database: MySQL
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update

ddl-auto

create：每次运行程序时，都会重新创建表，故而数据会丢失
create-drop：每次运行程序时会先创建表结构，然后待程序结束时清空表
upadte：每次运行程序，没有表时会创建表，如果对象发生改变会更新表结构，原有数据不会清空，只会更新（推荐使用）
validate：运行程序会校验数据与数据库的字段类型是否相同，字段不同会报错
none: 禁用DDL处理

【CRUD示例】

【实体类】

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_user")
public class User implements Serializable{

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)//strategy=GenerationType.IDENTITY 自增长
    @Column(name="userid")
    private Integer userid;

    @Column(name="username")
    private String username;

    @Column(name="userage")
    private Integer userage;

    public Integer getUserid() {
        return userid;
    }

    public void setUserid(Integer userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

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

    public Integer getUserage() {
        return userage;
    }

    public void setUserage(Integer userage) {
        this.userage = userage;
    }

    @Override
    public String toString() {
        return "User [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
    }

}

@GenericGenerator是Hibernate提供的主键生成策略注解

TABLE： 使用一个特定的数据库表格来保存主键
SEQUENCE： 根据底层数据库的序列来生成主键，条件是数据库支持序列。这个值要与generator一起使用，generator 指定生成主键使用的生成器（可能是orcale中自己编写的序列）
IDENTITY： 主键由数据库自动生成（主要是支持自动增长的数据库，如mysql）
AUTO： 主键由程序控制，也是GenerationType的默认值

【JpaRepository接口】

package com.example.springbootjpa.repository;

import com.example.springbootjpa.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, String> {
}

【测试类】

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {

    @Autowired
    private UserRepository userRepository;

    /**
     * 查询全部数据
     */
    @Test
    public void test1(){
        List<User> list  = this.userRepository.findAll();
        for (User users : list) {
            System.out.println(users);
        }
    }
}

【JpaSpecificationExecutor 接口】

public interface UsersDao extends JpaRepository<User,Integer>,JpaSpecificationExecutor<User>{

}

【单条件查询】

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {

    @Autowired
    private UsersDao usersDao;

    /**
     * 需求：根据用户姓名查询数据
     */
    @Test
    public void test1(){
        Specification<User> spec = new Specification<User>() {

            /**
             * @return Predicate:定义了查询条件
             * @param Root<Users> root:根对象。封装了查询条件的对象
             * @param CriteriaQuery<?> query:定义了一个基本的查询。一般不使用
             * @param CriteriaBuilder cb:创建一个查询条件
             */
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate pre = cb.equal(root.get("username"), "王五");
                return pre;
            }
        };
        List<User> list = this.usersDao.findAll(spec);
        for (User users : list) {
            System.out.println(users);
        }
    }
}

【多条件查询】

 @Test
    public void test3(){
        Specification<User> spec = new Specification<User>() {

            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                return cb.or(cb.equal(root.get("username"),"王五"),cb.equal(root.get("userage"), 25));
            }

        };
        List<User> list = this.usersDao.findAll(spec);
        for (User users : list) {
            System.out.println(users);
        }
    }

【分页与排序】

@Test
    public void test6(){
        //排序等定义
        Sort sort = new Sort(Direction.DESC,"userid");
        //分页的定义
        Pageable pageable = new PageRequest(2,2, sort);

        //查询条件
        Specification<User> spec = new Specification<User>() {

            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                return cb.like(root.get("username").as(String.class), "王%");
            }

        };
        Page<User> page = this.usersDao.findAll(spec, pageable);
        System.out.println("总条数："+page.getTotalElements());
        System.out.println("总页数："+page.getTotalPages());
        List<User> list = page.getContent();
        for (User users : list) {
            System.out.println(users);
        }
    }