Spring Boot JPA使用详解

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>

public enum Gender {
    MALE, FEMALE;
}

@Entity
@Table(name = "employee")
@Data
@EqualsAndHashCode
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false, columnDefinition = "varchar(50) COMMENT '姓名'")
    private String name;

    @Column(nullable = false, columnDefinition = "bit COMMENT '性别'")
    @Enumerated(EnumType.ORDINAL)
    private Gender gender = Gender.MALE;

    private Integer age;
}

public interface DefaultEmployeeDao extends JpaRepository<Employee, Long> {
}

public interface DefaultEmployeeDao extends JpaRepository<Employee, Long> {
    List<Employee> findByNameLike(String name);
}

@Service
public class DefaultEmployeeService {
    private static Logger log = LoggerFactory.getLogger(DefaultEmployeeService.class);

    @Autowired
    private DefaultEmployeeDao employeeDao;

    public Employee add(Employee employee) {
        return employeeDao.save(employee);
    }

    public Employee update(Employee employee) {
        return employeeDao.save(employee);
    }

    public void delete(Long id) {
        employeeDao.delete(id);
    }

    public List<Employee> queryAll() {
        return employeeDao.findAll();
    }

    public Employee getById(Long id) {
        return employeeDao.findOne(id);
    }

    public List<Employee> queryByName(String name) {
        name = "%" + name + "%";
        return employeeDao.findByNameLike(name);
    }
}

public interface Repository<T, ID extends Serializable> {
}

public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
    // 保存实体，返回保存后的实体
<S extends T> S save(S entity);

    // 保存所有给定的实体，如果参数为null，则抛出IllegalArgumentException。返回保存后的全部实体
<S extends T> Iterable<S> save(Iterable<S> entities);

    // 按照给定id查询实体，如果id为null，则抛出IllegalArgumentException，找到则返回带id的实体，否则返回null
    T findOne(ID id);

    // 判断给定id的实体是否存在，id不能为null，否则抛出IllegalArgumentException，如果存在则返回true，否则返回false
    boolean exists(ID id);

    // 查询所有实体对象
    Iterable<T> findAll();

    // 返回给定id列表的所有实体
    Iterable<T> findAll(Iterable<ID> ids);

    // 返回可用实体的数量
    long count();

    // 删除给定id的实体，id不能为null
    void delete(ID id);

    // 删除给定的实体，实体不能为null
    void delete(T entity);

    // 删除给定的所有实体，参数不能为null
    void delete(Iterable<? extends T> entities);

    // 删除所有实体
    void deleteAll();
}

public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
    // 查询所有实体，并按照给定规则排序
    Iterable<T> findAll(Sort sort);

    // 分页查询，返回分页对象
    Page<T> findAll(Pageable pageable);
}

public interface JpaRepository<T, ID extends Serializable>
        extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
    // 查询所有对象列表
    List<T> findAll();

    // 查询所有对象列表并进行排序
    List<T> findAll(Sort sort);

    // 查询给定一批id的实体
    List<T> findAll(Iterable<ID> ids);

    // 保存所有给定的实体
<S extends T> List<S> save(Iterable<S> entities);

    // 刷新到数据库
    void flush();

    // 保存实体并立即刷新到数据库
<S extends T> S saveAndFlush(S entity);

    // 批量删除给定实体
    void deleteInBatch(Iterable<T> entities);

    // 批量删除所有实体
    void deleteAllInBatch();

    // 获取单个实体，如果实体不存在，抛出EntityNotFoundException异常
    T getOne(ID id);

    // 查询匹配给定example的所有实体
<S extends T> List<S> findAll(Example<S> example);

    // 查询匹配给定example的所有实体并按给定规则排序
<S extends T> List<S> findAll(Example<S> example, Sort sort);
}

public interface JpaSpecificationExecutor<T> {
    // 根据给定条件查询单个对象
    T findOne(Specification<T> spec);

    // 查询所有匹配条件的实体
    List<T> findAll(Specification<T> spec);

    // 按照给定条件进行分页查询
    Page<T> findAll(Specification<T> spec, Pageable pageable);

    // 按照给定条件进行查询，并且排序
    List<T> findAll(Specification<T> spec, Sort sort);

    // 按照给定条件统计实体数量
    long count(Specification<T> spec);
}

public interface Specification<T> {
    // 使用给定的Root和CriteriaQuery对象构建一个Predicate，用于拼接where语句
    Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
}

Page<Employee> findByNameLikeOrderByIdAsc(String name, Pageable pageable);

Slice<Employee> findByAgeGreaterThanEqualOrderByIdAsc(int age, Pageable pageable);

``Page<T> findAll(Specification<T> spec, Pageable pageable);``

public Page<Employee> pageQueryByName(int pageIndex, int pageSize, String name) {
    // pageIndex从0开始
    Pageable pageable = new PageRequest(pageIndex, pageSize);
    return employeeDao.findByNameLikeOrderByIdAsc(name, pageable);
}

public Slice<Employee> pageQueryByAge(int pageIndex, int pageSize, int minAge) {
    Pageable pageable = new PageRequest(pageIndex, pageSize);
    return employeeDao.findByAgeGreaterThanEqualOrderByIdAsc(minAge, pageable);
}

public Page<Employee> pageQueryByNameAndAage(int pageIndex, int pageSize, String name, int minAge) {
    // 创建查询条件规则
    Specification<Employee> specification = (root, cq, cb) -> {
        List<Predicate> predicates = new ArrayList<>();
        if (StringUtils.hasLength(name)) {
            predicates.add(cb.and(cb.like(root.get("name"), name)));
        }
        if (minAge > 0) {
            predicates.add(cb.and(cb.greaterThanOrEqualTo(root.get("age"), minAge)));
        }
        if (predicates.size() > 0) {
            cq.where(predicates.toArray(new Predicate[predicates.size()]));
        }
        return cq.getRestriction();
    };
    // 创建排序规则
    Sort sort = new Sort(Sort.Direction.DESC, "id");
    // 创建分页对象
    Pageable pageable = new PageRequest(pageIndex, pageSize, sort);
    return employeeDao.findAll(specification, pageable);
}