五、Spring Boot 之数据访问(二)

作者: cqzhangjian | 来源:发表于2017-12-22 21:57 被阅读0次

一、Spring Data JPA

JPA (Java Persistence API) 是由 Hibernate 主导的 EJB 3.0 规范，不提供标准规范实现，JPA 标准规范实现由提供商实现，诸如提供商 Hibernate、EclipseLink、OpenJPA 等。

1. 定义数据访问层

public interface UserRepository extends JpaRepository<User, Long>{
  //定义数据访问操作的方法
}

UserRepository 接口继承 JpaRepository 接口，已经具有以下数据访问操作方法:

/*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll()
     */
    List<T> findAll();

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Sort)
     */
    List<T> findAll(Sort sort);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable)
     */
    List<T> findAll(Iterable<ID> ids);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable)
     */
    <S extends T> List<S> save(Iterable<S> entities);

    /**
     * Flushes all pending changes to the database.
     */
    void flush();

    /**
     * Saves an entity and flushes changes instantly.
     * 
     * @param entity
     * @return the saved entity
     */
    <S extends T> S saveAndFlush(S entity);

    /**
     * Deletes the given entities in a batch which means it will create a single {@link Query}. Assume that we will clear
     * the {@link javax.persistence.EntityManager} after the call.
     * 
     * @param entities
     */
    void deleteInBatch(Iterable<T> entities);

    /**
     * Deletes all entities in a batch call.
     */
    void deleteAllInBatch();

    /**
     * Returns a reference to the entity with the given identifier.
     * 
     * @param id must not be {@literal null}.
     * @return a reference to the entity with the given identifier.
     * @see EntityManager#getReference(Class, Object)
     */
    T getOne(ID id);

    /* (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example);

    /* (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);

2.配置使用 Spring Data JPA

在 Spring 环境中，使用 Spring Data JPA 可通过@EnableJpaRepositories 注解开启 Spring Data JPA 的支持，@EnableJpaRepositories 接受的 value 参数用来扫描数据访问层所在包下的数据访问的定义接口。

@SpringBootApplication
@EnableJpaRepositories(value="org.zj.repository")
public class SpringdatajpaApplication {
    
    @Bean
    public EntityEntryFactory entityEntryFactory(){
        //...
    }
        //还需要配置 DataSource、PlatformTransactionManager 等相关信息bean

3.定义查询方法

Spring Data JPA 支持自定义在 Respository 接口中的方法来定义查询，而方法名是根据实体类的属性名来确定。
自定义实体如下:

public class User {

    private Long id;
    private String name;
    private String password;
    private Integer age;
    private Double price;
    private boolean sex;
    private Date birth;

根据属性名定义查询方法:

    /**
     * 
     * 通过名字相等查询，参数为 name
     * 相当于 JPQL: SELECT u FROM USER u WHERE u.name= ?1
     * 
     */
    List<User> findByName(String name);
    
    /**
     * 通过名字 like 查询，参数为name
     * 相等于 JPQL: SELECT u FROM USER u WHERE u.name like =?1 
     */
    List<User> findByNameLike(String name);
    
    /**
     * 通过名称和密码查询，参数为name 和 password
     * 相当于 JPQL: SELECT u FROM USER u WHERE u.name=?1 AND u.password= ?2 
     */
    User getByNanmeAndPassword(String name, String password);

以上代码片段中出现的 findBy、getBy、Like、And 关键字，是帮助安装规则去查询，这样的关键子如表所示：

关键字	示例	同功能 JPQL
And	findByLastnameAndFirstname	where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	where x.lastname = ?1 or x.firstname = ?2
Is,Equals	findByFirstname,findByFirstnameIs,findByFirstnameEqual	where x.firstname = 1?
Between	findByStartDateBetween	where x.startDate between 1? and ?2
LessThan	findByAgeLessThan	where x.age < ?1
LessThanEqual	findByAgeLessThanEqual	where x.age = ?1
GreaterThan	findByAgeGreaterThan	where x.age > ?1
GreaterThanEqual	findByAgeGreaterThanEqual	where x.age >= ?1
After	findByStartDateAfter	where x.startDate > ?1
Before	findByStartDateBefore	where x.startDate < ?1
IsNull	findByAgeIsNull	where x.age is null
IsNotNull,NotNull	findByAge(Is)NotNull	where x.age not null
Like	findByFirstnameLike	where x.firstname like ?1
NotLike	findByFirstnameNotLike	where x.firstname not like ?1
StartingWith	findByFirstnameStartingWith	where x.firstname like ?1 (parameter bound with appended %)
EndingWith	findByFirstnameEndingWith	where x.firstname like ?1 (parameter bound with prepended %)
Containing	findByFirstnameContaining	where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy	findByAgeOrderByLastnameDesc	where x.age = ?1 order by x.lastname desc
Not	findByLastnameNot	where x.lastname <> ?1
In	findByAgeIn(Collection ages)	where x.age in ?1
NotIn	findByAgeNotIn(Collection age)	where x.age not in ?1
True	findByActiveTrue()	where x.active = true
False	findByActiveFalse()	where x.active = false
IgnoreCase	findByFirstnameIgnoreCase	where UPPER(x.firstame) = UPPER(?1)

限制结果数量，使用 Top 和 first 关键字来实现，诸如:

    /**
     * 
     * 通过名字相等查询前10条数据，参数为 name
     * 
     */
    List<User> findFirst10ByName(String name);
    
    /**
     * 
     * 通过名字相等查询前30条数据，参数为 name
     * 
     */
    List<User> findTop30ByName(String name);

使用 JPA 的 NamedQuery 查询，例子：

@Entity
@NamedQuery(name="User.findByAge",query="SELECT u FROM USER u WHERE u.age = ?1")
public class User {

使用如下语句：

    /**
     *  使用的是 NameQuery 里定义的查询语句，而不是根据方法名称查询 
     */
    List<User> findByAge(int age);

使用 @Query 查询

1.)使用参数索引

 @Query(value="SELECT u FROM USER u WHERE u.name = ?1")
List<User> findByName2(String name);

2.)使用命名参数

    @Query(value="SELECT u FROM USER u WHERE u.name = :name")
    List<User> findByName3(@Param("name") String name);

3.)更新查询

    @Transactional
    @Modifying
    @Query(value="UPDATE USER u SET u.name = ?1")
    int setName(String name);

4.)Specification(Criteria) 准则查询
Spring Data JPA 提供了一个Specification 规范接口完成构造准则查询， Specification 接口定义了 toPredicate 方法用来构造查询条件。

定义: 接口类必须实现 JpaSpecificationExecutor 接口

public interface UserRepository extends JpaRepository<User, Long>,JpaSpecificationExecutor<User>{

然后定义 Criterial 查询，代码如下:

public class UserSpecs {

    
    public static Specification<User> userByName(final String name){
        
        return new Specification<User>() {
            /**
             *  root : 通过 Root 获取查询属性
             *  cb   : 通过 CriteriaBuilder 构建查询条件
             */
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query,
                    CriteriaBuilder cb) {
                
                return cb.equal(root.get("name"), name);
            }
        };
    }
    
    
}

使用静态导入:

import static org.zj.springdatajpa.repository.spec.UserSpecs.*;

注入 userRepository 的 bean 后:

userRepository.findAll(userByName("张剑"));

排序与分页
Spring Data JPA 考虑到实际开发过程中有可能要排序和分页的场景，为我们提供了 Sort 类、Page 接口和 Pageable 接口。

1）定义

    List<User> findByName(String name,Sort sort);
    Page<User> findByName(String name,Pageable pageable);

2）使用

userRepository.findByName("xx",new Sort(Direction.ASC,"age"));
userRepository.findByName("xx",new PageRequest(0,10));

4.自定义 Repository 的实现过后再说

二、Spring Boot 支持

JDBC 的自动配置
spring-boot-starter-data-jpa 依赖 spring-boot-starter-jdbc，而 Spring Boot 对 JDBC 做了一些自动配置。源码如下图：

图片.png

查看源码可以看出，通过 “spring.datasoure” 为前缀的属性自动配置dataSoure；Spring Boot 自动开启了注解事务的支持(@EnableTransactionManagement)；还配置一个 jdbcTemplate。
Spring Boot 还提供了一个初始化数据的功能，放置在类路径下的schema.sql 文件会自动用来初始化表结构；放置在类路径下的data.sql 文件会自动用来填充表数据。

JPA 的自动配置
通过查看Spring Boot 对 JPA自动配置源码如图：

图片.png

Spring Boot 默认 JPA 的实现是 Hibernate；配置 JPA 使用 “spring.jpa” 为前缀的属性在 application.properties中配置。

Spring Data JPA 的自动配置
通过查看Spring Boot 对 Spring Data JPA自动配置源码如图：

图片.png

Spring Boot 自动开启了对 Spring Data JPA 的支持，所有不需在配置类中显示声明 @EnableJpaRepositories。

总结：
Spring Boot 使用 Spring Data JPA，在项目中条件 spring-boot-stater-data-jpa，然后只需要定义好 DataSource、实体类、数据访问层，并在需要使用数据访问的地方注入数据访问层的Bean就可以了。不需要额外的配置。

三、实战开发步骤

1. 安装docker 镜像 Oracle XE

图片.png

启动 Oracle XE 11g 容器:

docker run -d -p 9090:8080 -p 1521:1521 --name xe11g wnameless/oracle-xe-11g

运行 xe11g 容器：

docker start xe11g

外部访问 xe11g 管理界面:

图片.png

2.创建 Spring Boot 项目

图片.png

在类路径下创建 data.sql 测试数据

INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'张剑',30,'重庆');
INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'老何',31,'重庆');
INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'辉辉',28,'重庆');
INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'春春',29,'重庆');
INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'老严',35,'重庆');
INSERT INTO PERSON (ID,NAME,AGE,ADDRESS) VALUES (HIBERNATE_SEQUENCE.NEXTVAL,'老邓',18,'重庆');

创建实体

@Entity
@NamedQuery(name="Person.byNameAndAddressNameQuery",query="SELECT p FROM Person p WHERE p.name =?1 AND p.address=?2")
public class Person {
    @Id
    @GeneratedValue //hibernate 自动生成 HIBERNATE_SEQUENCE序列
    private Long id;
    private String name;
    private Integer age;
    private String address;

配置基本属性

spring.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@192.168.0.112:1521:xe
spring.datasource.username=ZHANGJIAN
spring.datasource.password=zhangjian

#1
spring.jpa.hibernate.ddl-auto=update
#2
spring.jpa.show-sql=true
#3
spring.jackson.serialization.indent_output=true

定义数据访问接口

public interface PersonRepository extends JpaRepository<Person, Long> {
    
    List<Person> findByAddress(String address);
    Person findByNameAndAddress(String name,String address);
     
    @Query("SELECT p FROM Person p WHERE p.name= :name AND p.address= :address")
    Person byNameAndAddressQuery(@Param("name")String name,@Param("address")String address);
    
    Person byNameAndAddressNameQuery(String name,String address);

}

定义控制器业务层省略

@RestController
public class HelloController {
    
    @Autowired
    PersonRepository personRepository;
    
    @RequestMapping(value="/save")
    public Person save(String name,String address,Integer age){
        Person p = new Person(null,name,age,address);
        personRepository.save(p);
        return p;
    }
    
    @RequestMapping(value="/p1")
    public List<Person> p1(String  address){
        
        return personRepository.findByAddress(address);
    }
    
    @RequestMapping(value="/p2")
    public Person p2(String name,String  address){
        return personRepository.findByNameAndAddress(name, address);
    }
    
    @RequestMapping(value="/p3")
    public Person p3(String name,String  address){
        return personRepository.byNameAndAddressQuery(name, address);
    }
    @RequestMapping(value="/p4")
    public Person p4(String name,String  address){
        return personRepository.byNameAndAddressNameQuery(name, address);
    }
    
    /**
     * 测试排序
     */
    @RequestMapping(value="/sort")
    public List<Person> sort() {
        return personRepository.findAll(new Sort(Direction.ASC, "age"));
    }
    /**
     * 测试分页
     */
    @RequestMapping(value="/page")
    public Page<Person> page() {
        return personRepository.findAll(new PageRequest(1, 2));
    }
}