spring data jpa

 

SpringData概述

       Spring Data : Spring 的一个子项目。Spring Data的任务是为数据访问提供一个熟悉的、一致的、基于Spring的编程模型，同时仍然保留底层数据存储的特殊特性.简言之就是用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。

 SpringData 项目所支持 NoSQL 存储：

• MongoDB （文档数据库）
• Neo4j（图形数据库）
• Redis（键/值存储）
• Hbase（列族数据库）

SpringData 项目所支持的关系数据存储技术：

• JDBC
• JPA

JPA Spring Data概述

       JPA Spring Data :很容易实现基于JPA的Repository。此模块处理对基于JPA的数据访问层的增强支持 。实现应用程序的数据访问层有一段时间很麻烦。为了执行简单的查询以及执行分页和统计，必须编写太多样板代码SpringDataJPA的目标是通过将工作减少到实际需要的数量来显著改进数据访问层的实现。作为开发人员，您可以编写存储库接口，包括定制的find方法，Spring将自动提供实现。

       框架怎么可能代替开发者实现业务逻辑呢？比如：当有一个 UserDao.findUserById()  这样一个方法声明，大致应该能判断出这是根据给定条件的 ID 查询出满足条件的 User  对象。Spring Data JPA 做的便是规范方法的名字，根据符合规范的名字来确定方法需要实现什么样的逻辑，背后通过动态代理生成其具体的实现不需要开发者自己去实现，下面我们完成一个入门版本。

使用 Spring Data JPA 进行持久层开发需要的步骤：

• 搭建环境
• 配置 Spring 整合 JPA

添加相关依赖

dependencies {
    compile group: 'com.alibaba', name: 'druid', version: '1.1.17'
    compile group: 'org.springframework.data', name: 'spring-data-jpa', version: '2.1.8.RELEASE'
    compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.16'
    compile group: 'org.hibernate', name: 'hibernate-core', version: '5.4.3.Final'
    testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.7.RELEASE'

    testCompile group: 'junit', name: 'junit', version: '4.12'
}

 

xml配置

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/data/jpa 
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    <context:component-scan base-package="com.wise.tiger"/>
     <context:property-placeholder location="classpath:pool-config.properties"/>
    <!-- 数据源配置 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--property name="driverClassName" value="${driverClass}"/-->
        <property name="url" value="${url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${password}" />
	<property name="password" value="${password}" />
	<property name="password" value="${password}" />
	<property name="defaultAutoCommit" value="${defaultAutoCommit}" />
	<property name="connectionProperties" value="${connectionProperties}" />
    </bean>

    <!-- Hibernate对Jpa的实现 -->
    <bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>

    <!-- 定义实体管理器工厂
         Jpa配置   LocalContainerEntityManagerFactoryBean这个选项Spring扮演了容器的角色。完全掌管JPA -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!-- 指定数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 指定Jpa持久化实现厂商类,这里以Hibernate为例 -->
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/>
        <!-- 指定Entity实体类包路径 -->
        <property name="packagesToScan" >
            <array>
                <value>com.wise.tiger.domain</value>
            </array>
        </property>
        <!-- 指定JPA属性；如Hibernate中指定是否显示SQL的是否显示、方言等 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</prop>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
    
    <!-- Jpa 事务管理器  -->
    <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!-- 开启注解事务 -->
   <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

  <jpa:repositories base-package="com.wise.tiger.repository" 
           entityManagerFactoryRef="entityManagerFactory",
           transactionManagerRef="txManager" />

</beans>

 

java配置

@Configuration
@EnableJpaRepositories(basePackages="com.wise.tiger.repository",
                       entityManagerFactoryRef="entityManagerFactory",
                       transactionManagerRef="txManager")
@PropertySource(value = "classpath:pool-config.properties",encoding = "UTF-8") 
@EnableTransactionManagement
public class ApplicationConfig {
    @Bean
    public DataSource dataSource(@Value("${driverClassName}") String driverClassName,
                                 @Value("${url}") String url,
                                 @Value("${jdbc.username}") String username,
                                 @Value("${password}") String password,
                                 @Value("${connectionProperties}") String connectionProperties,
                                 @Value("${defaultAutoCommit}") boolean isAutoCommit){
        var dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDefaultAutoCommit(isAutoCommit);
        dataSource.setConnectionProperties(connectionProperties);
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource){
        var entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactory.setDataSource(dataSource);
        var jpaAdapter = new HibernateJpaVendorAdapter();

        entityManagerFactory.setPackagesToScan("com.wise.tiger.domain");
        entityManagerFactory.setJpaVendorAdapter(jpaAdapter);
        var propertiesMap = new HashMap<String,String>();
        propertiesMap.put("hibernate.dialect","org.hibernate.dialect.MySQL8Dialect");
        propertiesMap.put("hibernate.show_sql","true");
        propertiesMap.put("hibernate.hbm2ddl.auto","update");
        entityManagerFactory.setJpaPropertyMap(propertiesMap);
        return entityManagerFactory;
    }
    @Bean
    public JpaTransactionManager txManager(EntityManagerFactory factory){
        return new JpaTransactionManager(factory);
    }
}

 

• 在 Spring 配置文件中配置 Spring Data，让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package  指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。
• 声明持久层的接口，该接口继承  Repository，Repository 是一个标记型接口，它不包含任何方法，如必要，Spring Data 可实现 Repository 其他子接口，其中定义了一些常用的增删改查，以及分页相关的方法。
• 在接口中声明需要的方法。Spring Data 将根据给定的策略（具体策略稍后讲解）来为其生成实现代码。

Repository接口

      Repository 接口是 spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法

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

        Spring Data可以让我们只定义接口，只要遵循 Spring Data的规范，就无需写实现类。 
       与继承 Repository 等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定 domainClass 和 idClass 属性。如下两种方式是完全等价的

public interface BookRepository extends Repository<Book,Integer>{
}

// *********************等价于***********************//

@RepositoryDefinition（domainClass=Book.class,idClass=Integer.class）
public interface BookRepository{
}

Repository的子接口

基础的 Repository 提供了最基本的数据访问功能，其几个子接口则扩展了一些功能。它们的继承关系如下：

• Repository： 仅仅是一个标识，表明任何继承它的均为仓库接口类
• CrudRepository： 继承 Repository，实现了一组 CRUD 相关的方法 
• PagingAndSortingRepositor： 继承 CrudRepository，实现了一组分页排序相关的方法 
• JpaRepository： 继承 PagingAndSortingRepository，实现一组 JPA 规范相关的方法 
• 自定义的 XxxxRepository 需要继承 JpaRepository，这样的 XxxxRepository 接口就具备了通用的数据访问控制层的能力。
• JpaSpecificationExecutor： 不属于Repository体系，实现一组 JPA Criteria 查询相关的方法 

Spring Data方法定义规范

       简单条件查询: 查询某一个实体类或者集合 

       按照 Spring Data 的规范，查询方法以 find | read | get 开头， 涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。 例如：定义一个 Entity 实体类User

 

@Entity
public class User｛
    @Id @GeneratedValue
    private Integer id;
    @Column(length = 10)
    private String firstName; 
    @Column(length = 10)   
    private String lastName; 
// *****************setter and getter********************//
｝

       使用And条件连接时，应这样写： findByLastNameAndFirstName(String lastName,String firstName); 条件的属性名称与个数要与参数的位置与个数一一对应。直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，目前支持的关键字写法如下：

 

 

Keyword Sample JPQL snippet

And	findByLastnameAndFirstname	… where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Is,Equals	findByFirstname,findByFirstnameIs,findByFirstnameEquals	… 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<Age> ages)	… where x.age in ?1
NotIn	findByAgeNotIn(Collection<Age> ages)	… 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)

List<Person> findByAddressZipCode(ZipCode zipCode);框架在解析该方法时，首先剔除 findBy，然后对剩下的整个部分（addressZipCode）解析为属性，假设查询实体为Persoon先判断 addressZipCode（根据 POJO 规范驼峰命名规范）是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，继续第二步；从右往左截取第一个大写字母开头的字符串(此处为zipCode)，然后检查剩下的字符串是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，则重复第二步，继续从右往左截取。可能会存在一种特殊情况，比如 Person包含一个 addressZip的属性，此时会存在混淆。可以明确在属性之间加上 "_" 以显式表达意图，比如List<Person> findByAddress_ZipCode(ZipCode zipCode)

特殊的参数： 还可以直接在方法的参数上加入分页或排序的参数，比如：

Page<User> findByLastname(String lastname, Pageable pageable);

Slice<User> findByLastname(String lastname, Pageable pageable);

List<User> findByLastname(String lastname, Sort sort);

List<User> findByLastname(String lastname, Pageable pageable);

 限定查询：查询方法的结果可以通过使用first或top关键字来限制，这些关键字可以互换使用

User findFirstByOrderByLastnameAsc();

User findTopByOrderByAgeDesc();

Page<User> queryFirst10ByLastname(String lastname, Pageable pageable);

Slice<User> findTop3ByLastname(String lastname, Pageable pageable);

List<User> findFirst10ByLastname(String lastname, Sort sort);

List<User> findTop10ByLastname(String lastname, Pageable pageable);

 流式查询结果：查询方法的结果可以通过使用Java8 Stream<t>作为返回类型来增量处理。不是将查询结果包装在流中，而是使用特定的方法来执行Stream，如下面的示例所示：

@Query("select u from User u")
Stream<User> findAllByCustomQueryAndStream();

Stream<User> readAllByFirstnameNotNull();

@Query("select u from User u")
Stream<User> streamAllPaged(Pageable pageable);

 流可能包含潜在的数据存储特定的资源，因此必须在使用后关闭。

try (Stream<User> stream = repository.findAllByCustomQueryAndStream()){
  stream.forEach(…);
}

使用@Query注解

       使用@Query自定义查询:这种查询可以声明在 Repository 方法中，摆脱像命名查询那样的约束，将查询直接在相应的接口方法中声明，结构更为清晰，这是 Spring data 的特有实现。

      索引参数与命名参数

• 索引参数如下所示，索引值从1开始，查询中 ”?X” 个数需要与方法定义的参数个数相一致，并且顺序也要一致 

public interface UserRepository extends JpaRepository<User, Long> {
  @Query("select u from User u where u.emailAddress = ?1")
  User findByEmailAddress(String emailAddress);
}

• 命名参数（推荐使用这种方式）：可以定义好参数名，赋值时采用@Param("参数名")，而不用管顺序。

public interface UserRepository extends JpaRepository<User, Long> {

  @Query("select u from User u where u.firstname = :firstname or u.lastname = :lastname")
  User findByLastnameOrFirstname(@Param("lastname") String lastname,
                                 @Param("firstname") String firstname);
}

     如果是 @Query 中有 LIKE 关键字，后面的参数需要前面或者后面加 %，这样在传递参数值的时候就可以不加 %：

@Query("select o from User o where o.name like ?1%")
     public List<User> findByUuidOrAge(String name);
@Query("select o from User o where o.name like %?1")
    public List<User> findByUuidOrAge(String name);
@Query("select o from User o where o.name like %?1%")
    public List<User> findByUuidOrAge(String name);

      用@Query来指定本地查询

还可以使用@Query来指定本地查询，只要设置nativeQuery为true，比如：

@Query(value="select * from tb_user where name like %?1" ,nativeQuery=true)
    public List<UserModel> findByUuidOrAge(String name);

@Modifying 注解和事务

 

       @Query 与 @Modifying 这两个 annotation一起声明，可定义个性化更新操作，例如只涉及某些字段更新时最为常用，示例如下： 

@Modifying
@Query("update User u set u.firstname = ?1 where u.lastname = ?2")
int setFixedFirstnameFor(String firstname, String lastname);

注意：

• 方法的返回值应该是 int，表示更新语句所影响的行数
• 在调用的地方必须加事务，没有事务不能正常执行(事务一般定义在service层，代表一个业务边界）

       Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。对于自定义的方法，如需改变 Spring Data 提供的事务默认方式，可以在方法上注解 @Transactional 声明。进行多个 Repository 操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要Service 层实现对多个 Repository 的调用，并在相应的方法上声明事务。

 

CrudRepository子接口

CrudRepository 接口提供了最基本的对实体类的添删改查操作 

 

• T save(T entity);//保存单个实体 
• Iterable<T> save(Iterable<? extends T> entities);//保存集合        
• T findOne(ID id);//根据id查找实体         
• boolean exists(ID id);//根据id判断实体是否存在         
• Iterable<T> findAll();//查询所有实体,不用或慎用!         
• long count();//查询实体数量         
• void delete(ID id);//根据Id删除实体         
• void delete(T entity);//删除一个实体 
• void delete(Iterable<? extends T> entities);//删除一个实体的集合         
• void deleteAll();//删除所有实体,不用或慎用!

PagingAndSortingRepository子接口

PagingAndSortingRepository接口提供了分页与排序功能 

• Iterable<T> findAll(Sort sort); //排序 
• Page<T> findAll(Pageable pageable); //分页查询（含排序功能） 

JpaRepository的子接口

JpaRepository接口提供了JPA的相关功能 

• List<T> findAll(); //查找所有实体 
• List<T> findAll(Sort sort); //排序、查找所有实体 
• List<T> save(Iterable<? extends T> entities);//保存集合 
• void flush();//执行缓存与数据库同步 
• T saveAndFlush(T entity);//强制执行持久化 
• void deleteInBatch(Iterable<T> entities);//删除一个实体集合 

JpaSpecificationExecutor接口

JpaSpecificationExecutor接口：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法

• Specification：封装  JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象

  @Test public void query(){
          //模拟传递一个排序属性（排序的有：按销售价格从高到低排序(sellpricedesc);按销售价格从低到高排序(sellpriceasc)，销售总量降序(selldesc)，默认出版日期降序排列）
          var order = "selldesc";
          var sort = buildSort(order);//排序规则
  
          //模拟当前第一页(当前页从0开始的)以及每页显示20条记录,实际为service传递的参数
          var pageable = PageRequest.of(0,20,sort);
          /**
           * 构建多条件（动态条件）查询，查询标题包含"射雕"，或者出版社包含"三联"且在售的图书
           */
          repository.findAll((root,query,cb)->{
              //首先要求图书是上架在售的
              var predicate = cb.equal(root.get("visible"), true);
              var predicate1 = cb.like(root.get("title"),"%射雕%");
              var predicate2 = cb.like(root.get("publisher"),"%三联%");
              return cb.and(predicate,cb.or(predicate1,predicate2));
          },pageable);
  
  
          //查询id在[1,3,5,7,9,10]的图书（in查询)===>@Query("select o from Book o where o.id in :ids")
          repository.findAll((root,query,cb)->{
              var ids = new int[]{1,3,5,7,9,10};
              var in = cb.in(root.get("id"));
              Arrays.stream(ids).forEach(in::value);
              return query.where(in).getRestriction();
          });
      }
  
      /**
       * 排序规则
       * @param sort 排序规则说明
       * @return
       */
      private Sort buildSort(String sort){
          if("selldesc".equals(sort))
              return Sort.by(Sort.Direction.DESC,"sellCount");
          else if("sellpricedesc".equals(sort))
              return Sort.by(Sort.Direction.DESC,"sellPrice");
          else if("sellpriceasc".equals(sort))
              return Sort.by(Sort.Direction.ASC,"sellPrice");
          else
              return Sort.by(Sort.Direction.DESC,"listedDate");
  
      }

   

自定义Repository方法

A、为某一个 Repository 上添加自定义方法

步骤：

1. 定义一个接口: 声明要添加的, 并自实现的方法
2. 提供该接口的实现类: 类名需在要声明的 Repository 后添加 Impl, 并实现方法
3. 声明 Repository 接口, 并继承 1) 声明的接口

使用.
注意: 默认情况下, Spring Data 会在 base-package 中查找 "接口名Impl" 作为实现类. 也可以通过　repository-impl-postfix　声明后缀.
B、-为所有的 Repository 都添加自实现的方法

步骤：

1. 声明一个接口, 在该接口中声明需要自定义的方法, 且该接口需要继承 Spring Data 的 Repository.
2. 提供 1) 所声明的接口的实现类. 且继承 SimpleJpaRepository, 并提供方法的实现
3. 定义 JpaRepositoryFactoryBean 的实现类, 使其生成 1) 定义的接口实现类的对象
4. 修改 <jpa:repositories /> 节点的 factory-class 属性指向 3) 的全类名

注意: 全局的扩展实现类不要用 Imp 作为后缀名, 或为全局扩展接口添加 @NoRepositoryBean 注解告知  Spring Data: Spring Data 不把其作为 Repository