SpringData整合JPA

最新推荐文章于 2024-06-28 16:28:01 发布

Bart_G

最新推荐文章于 2024-06-28 16:28:01 发布

阅读量635

点赞数 1

分类专栏： springdata 文章标签： springdata jpa

本文链接：https://blog.csdn.net/rocky_03/article/details/62038219

版权

springdata 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

SpringData概述

Spring Data : Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和关系数据存储。其主要目标是使数据库的访问变得方便快捷。
SpringData 项目所支持 NoSQL 存储：
- MongoDB （文档数据库）
- Neo4j（图形数据库）
- Redis（键/值存储）
- Hbase（列族数据库）
SpringData 项目所支持的关系数据存储技术：
- JDBC
- JPA

SpringData整合JPA示例

添加JPA，SpringData的JAR包

1. 配置jdbc.properties

jdbc.user=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://127.0.0.1\:3306/jpa

2.配置Spring的applicationContext.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:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 配置自动扫描 -->
    <context:component-scan base-package="com.bart.springdata" />

    <!-- 1.配置数据源 -->
    <context:property-placeholder location="classpath:jdbc.properties" ></context:property-placeholder>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
    </bean>

    <!-- 2.配置 JPA 的EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 2.1 配置 JPA 提供商的适配器. 可以通过内部 bean 的方式来配置 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>
        <!-- 2.2 配置实体类所在的包 -->
        <property name="packagesToScan" value="com.bart.springdata" />
        <!-- 2.3 配置 JPA 的基本属性  -->
        <property name="jpaProperties" >
            <props>
                <!-- 二级缓存相关 -->
                <!--  
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                <prop key="net.sf.ehcache.configurationResourceName">ehcache-hibernate.xml</prop>
                -->
                <!-- 生成的数据表的列的映射策略 -->
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <!--  Hibernate 基本属性 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</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>
    <!-- 3. 配置事务管理 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>
    <!-- 4. 配置支持注解的事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 5. 配置 SpringData -->
    <!-- 加入 jpa 的命名空间 -->
    <!-- base-package: 扫描 Repository Bean 所在的 package --> 
    <jpa:repositories base-package="com.bart.springdata"
        entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
</beans>

到这里整合基本配置完毕。
下面进行测试，熟悉SpringData和JPA整合之后的一些特性。

3. 创建测试的entity

Person和Address是单向多对一关联关系
Person.java

package com.bart.springdata.entity;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Table(name="jpa_persons")
@Entity
public class Person {

    @Column(name="add_id")
    public Integer getAddressId() {
        return addressId;
    }
    public void setAddressId(Integer addressId) {
        this.addressId = addressId;
    }
    @ManyToOne
    @JoinColumn(name="address_id")
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", email=" + email
                + ", birth=" + birth + "]";
    }
    @Id
    @GeneratedValue
    @Column(length=10)
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    @Column(name="last_name",length=10)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Column(length=20)
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    private Integer id;
    private String name;
    private String email;
    private Date birth;
    private Address address;
    private Integer addressId;    
}

Address.java

package com.bart.springdata.entity;

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

@Table(name="jpa_address")
@Entity
public class Address {

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    @Column(name="last_name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private Integer id;
    private String name;

}

Repository 接口概述

Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法public interface Repository<T, ID extends Serializable> { }
Spring Data可以让我们只定义接口，只要遵循Spring Data的规范，就无需写实现类。
与继承 Repository 等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定 domainClass 和 idClass 属性。如下两种方式是完全等价的

Repository 的子接口

基础的 Repository 提供了最基本的数据访问功能，其几个子接口则扩展了一些功能。它们的继承关系如下：
- Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类
- CrudRepository：继承 Repository，实现了一组 CRUD 相关的方法
- PagingAndSortingRepository：继承 CrudRepository，实现了一组分页排序相关的方法
- JpaRepository：继承 PagingAndSortingRepository，实现一组 JPA 规范相关的方法
自定义的 XxxxRepository 需要继承 JpaRepository，这样的 XxxxRepository 接口就具备了通用的数据访问控制层的能力。
JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法

1. 继承Repository接口

Repository 是一个空接口，即一个标记接口
若我们定义的接口继承了 Repository，则该接口被IOC容器识别为一个 Repository Bean 纳入到 IOC 容器中。进而可以在该接口中定义满足一定的规范。
实际上，也可以通过@RepositoryDefinition 注解来替代继承Repository
注意：继承该接口无法进行insert操作，当执行delete和update的时候需要在PersonService定义相关的方法,而且PersonRepository中必须使用@Modifying和@Query修饰
支持的关键字

创建PersonRepository.java的接口

/**
 * 需要实现Repository<Person,Integer>接口
 * 注意： 泛型第一个是要处理的实体类Person，第二个是主键类型
 * 在 Repository 子接口中声明方法
 * 1. 不是随便声明的，而需要一定的规范
 * 2. 查询方法以 find | read | get 开头
 * 3. 涉及到条件查询的时候，条件的属性用条件关键字链接
 * 4. 要注意的是，条件属性以首字母大写  
 * 5. 支持属性的级联查询，若当前类有符合条件的属性，则优先使用，而不是用级联的属性
 *    若需要使用级联属性，则属性之间使用_进行连接
 *
 */
//@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
public interface PersonRepository extends Repository<Person,Integer> {
    // 普通的查询方法
    // 示例 getByName(String name):getBy固定用法
    //1. Name是Person成员变量的首字母大写
    //2. name与Person的成员变量name相同
    public Person getByName(String name);

    //查询name以?开头的并且id小于?的所有Person的集合
    //WHERE name LIKE ?% AND id < ?
    public List<Person> getByNameStartingWithAndIdLessThan(String name, Integer id);

    //查询name以?结尾的并且id小于?的所有Person的集合
    //WHERE name LIKE %? AND id < ?
    List<Person> getByNameEndingWithAndIdLessThan(String name, Integer id);

    //WHERE email IN (?, ?, ?) OR birth < ?
    List<Person> getByEmailIn(List<String> emails);

    //WHERE a.id > ?
    List<Person> getByAddress_IdGreaterThan(Integer id);

    /**自定义查询的方法,查询最大id的person对象
     *自定义注解更加灵活使用jpsql语句查询
     */
    @Query("select p from Person p where p.id=(select max(p2.id) from Person p2)")
    public Person getMaxId();

    //1.使用占位符传递参数,参数顺序必须和占位符顺序一样
    @Query("select p from Person p where p.name=?1 and p.email=?2")
    public Person getByNameAndEmail(String name,String email);

    //2.使用命名参数,参数顺序可以不相同
    @Query("select p from Person p where p.name=:name and p.email=:email")
    public Person getByNameAndEmail2(@Param("email")String emai,@Param("name")String namel);

    //1.使用占位符查询like
    @Query("select p from Person p where p.name like %?1% or p.name like %?2%")
    public List<Person> getByLikeName(String name1,String name2);

    //2.使用命名参数查询like
    @Query("select p from Person p where p.name like %:name% or p.name like %:email%")
    public List<Person> getByLikeName2(@Param("email")String emai,@Param("name")String name);

    // 使用原声的SQL语句查询,注意nativeQuery=true
    @Query(value="select count(*) from jpa_persons",nativeQuery=true)
    public long getPersonCount();

    //可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT
    //在 @Query 注解中编写 JPQL 语句, 但必须使用 @Modifying 进行修饰. 以通知 SpringData, 这是一个 UPDATE 或 DELETE 操作
    //UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作. 
    //默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!
    @Modifying
    @Query("update Person p set p.email=:email  where p.id=:id")
    public void updateEmailById(@Param("email")String email,@Param("id")Integer id);
}

2. 创建PersonService

PersonService.java

package com.bart.springdata.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.bart.springdata.entity.Person;
import com.bart.springdata.repository.PersonRepository;

@Service
public class PersonService {

    @Autowired
    private PersonRepository repository;

    @Transactional
    public void updateEmailById(String email,Integer id){
        repository.updateEmailById(email, id);
    }    
}

3. 测试

public class TestSpringData {

    private ApplicationContext context = null;
    private PersonRepository repository = null;
    private PersonService personService=null;
    {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
        repository = context.getBean(PersonRepository.class); 
        personService = context.getBean(PersonService.class);
    }

    /**
     * 1. 测试repository接口规范的定义查询方法
     */
    @Test
    public void testRepository(){
        //查询以“DD”开头，“id”小于16的所有person
        List<Person> list = repository.getByNameStartingWithAndIdLessThan("DD",16);
        System.out.println(list);
        //查询以“DD”结尾，“id”小于16的所有person
        List<Person> list1 = repository.getByNameEndingWithAndIdLessThan("DD", 16);
        System.out.println(list1);
        //查询email在一个list中的Person
        List<String>emails = Arrays.asList("AA@163.com", "FF@163.com", 
                "SS@163.com");
        List<Person> list2 = repository.getByEmailIn(emails);
        System.out.println(list2.size());
        //查询Person字段名与Address_id重合的情况
        List<Person>list3=repository.getByAddress_IdGreaterThan(1);
        System.out.println(list3);

    }

 // 2.1 查询自定义的 jpasql 
    @Test
    public void testAnnotationQuery(){
        Person person = repository.getMaxId();
        System.out.println(person);
        Person p2 = repository.getByNameAndEmail("AA", "aa@163.com");
        System.out.println(p2);
        Person p3 = repository.getByNameAndEmail2("aa@163.com","AA");
        System.out.println(p3);
    }
    // 2.2 自定义的like 的查询
    @Test
    public void testAnnotationQuery2(){
        //查询名字包含AA或BB的所有Person
        List<Person> list = repository.getByLikeName("DD","BB");
        System.out.println(list.size());
        List<Person> list2 = repository.getByLikeName("DD","aa@163.com");
        System.out.println(list2.size());
        //查询person的总数
        long l = repository.getPersonCount();
        System.out.println(l);
    }
    // 3. 测试Update
    @Test
    public void testUpdate(){
        personService.updateEmailById("AAAAA@qq.com",1);
    }
}

2. 继承CrudRepository接口

继承该接口之后，在PersonRepository接口中无序再定义先关的CRUD方法
在PersonService中直接调用CRUD方法即可

API

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();//删除所有实体,不用或慎用!

PersonRepository.java

public interface PersonRepository extends CrudRepository{
    //什么都不需要写，只需要在PersonService中调用CrudRepository中的方法做相关的操作即可
}

PersonService.java

package com.bart.springdata.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.bart.springdata.entity.Person;
import com.bart.springdata.repository.PersonRepository;

@Service
public class PersonService {
    @Autowired
    private PersonRepository repository;    
    //调用PersonService接口继承于CrudRepository接口的方法
    @Transactional
    public void savePerson(List<Person>persons){
        repository.save(persons);
    }
}

测试：

//测试批量保存数据
    @Test
    public void testSave(){
        List<Person>persons=new ArrayList<Person>();
        for(int i='a';i<='z';i++){
            Person person = new Person();
            person.setName((char)i+""+(char)i);
            person.setEmail((char)i+""+(char)i+"@163.com");
            person.setBirth(new Date());
            persons.add(person);
        }
        personService.savePerson(persons);
    }

可以看到，继承CrudRepository接口之后，很非常方便的，SpringData提供了写好的CRUD操作

3. 继承PagingAndSortingRepository接口

API

//该接口提供了分页与排序功能 
Iterable<T> findAll(Sort sort); //排序 
Page<T> findAll(Pageable pageable); //分页查询（含排序功能）

PersonRepository .java

public interface PersonRepository extends PagingAndSortingRepository{
    //什么都不需要写
}

测试

//测试分页
    @Test
    public void testPagingAndSortingRepository(){
        int currPage = 3-1;//当前页数，从0开始
        int pageSize = 5;//每页显示数据数
        //定义排序规则
        Order order1 = new Order(Direction.ASC,"id");//按照id降序排列
        Order order2 = new Order(Direction.DESC,"name");//按照name升序排列
        //排序方式
        Sort sort = new Sort(order1,order2);
        //创建Page接口的实现类PageRequest
        PageRequest pageRequest = new PageRequest(currPage, pageSize,sort);

        Page<Person>pages = repository.findAll(pageRequest);

        System.out.println("总记录数："+pages.getTotalElements());//27
        System.out.println("当前第几页："+(pages.getNumber()+1));//3
        System.out.println("总页数："+pages.getTotalPages());//6
        System.out.println("当前页面内容："+pages.getContent());
        System.out.println("当前页面实际的记录数："+pages.getNumberOfElements());//5
        System.out.println("每页显示的数据："+pages.getSize());//5
    }

4.继承JpaRepository接口

PagingAndSortingRepository能做的他都能做

API

//该接口提供了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);//删除一个实体集合

PersonRepository .java

public interface PersonRepository extends JpaRepository{
    //什么都不需要写
}

测试

@Test
    public void testJpaRepository(){
        Person person = new Person();
        person.setBirth(new Date());
        person.setEmail("XXX@163.com");
        person.setName("XXX");
        person.setId(30);
        Person person2 = repository.saveAndFlush(person);
        System.out.println(person==person2);//false,类似JPA的Merge方法
    }

5. 继承JpaSpecificationExecutor接口

带自定义查询条件的分页

不属于Repository体系，实现一组 JPA Criteria 查询相关的方法
Specification：封装 JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象

PersonRepository .java

public interface PersonRepository extends JpaSpecificationExecutor{
    //什么都不需要写
}

测试

    /**
     * 目标: 实现带查询条件的分页. id > 5 的条件
     * 
     * 调用 JpaSpecificationExecutor 的 Page<T> findAll(Specification<T> spec, Pageable pageable);
     * Specification: 封装了 JPA Criteria 查询的查询条件
     * Pageable: 封装了请求分页的信息: 例如 pageNo, pageSize, Sort
     */
    @Test
    public void testJpaSpecificationExecutor(){
        int currPage = 3-1;//当前页数，从0开始
        int pageSize = 5;//每页显示数据数
        PageRequest pageRequest = new PageRequest(currPage, pageSize);
      //通常使用 Specification 的匿名内部类
        Specification<Person> specification = new Specification<Person>() {
            /**
             * @param *root: 代表查询的实体类. 
             * @param query: 可以从中可到 Root 对象, 即告知 JPA Criteria 查询要查询哪一个实体类. 还可以
             * 来添加查询条件, 还可以结合 EntityManager 对象得到最终查询的 TypedQuery 对象. 
             * @param *cb: CriteriaBuilder 对象. 用于创建 Criteria 相关对象的工厂. 当然可以从中获取到 Predicate 对象
             * @return: *Predicate 类型, 代表一个查询条件. 
             */
            @Override
            public Predicate toPredicate(Root<Person> root,
                    CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path path = root.get("id");
                Predicate predicate = cb.gt(path, 5);
                return predicate;
            }
        };
        Page<Person>pages = repository.findAll(specification, pageRequest);
        System.out.println("总记录数："+pages.getTotalElements());
        System.out.println("当前第几页："+(pages.getNumber()+1));
        System.out.println("总页数："+pages.getTotalPages());
        System.out.println("当前页面内容："+pages.getContent());
        System.out.println("当前页面实际的记录数："+pages.getNumberOfElements());
        System.out.println("每页显示的数据："+pages.getSize());
    }

6. 自定义 Repository 方法

继承抽象类PersonDao并且，创建PersonRepositoryImpl的实现类
当PersonRepository调用PersonDao的方法就相当于调用PersonRepositoryImpl的对应的实现方法

创建PersonDao和PersonRepositoryImpl实现类

PersonDao.java

package com.bart.springdata.dao;
import com.bart.springdata.entity.Person;
public interface PersonDao {
    public Person getMyPersonBy(Integer id);
}

PersonRepositoryImpl.java

package com.bart.springdata.dao;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.bart.springdata.entity.Person;
public class PersonRepositoryImpl implements PersonDao{
    @PersistenceContext
    private EntityManager entityManager;    
    @Override
    public Person getMyPersonBy(Integer id) {
        Person person = entityManager.find(Person.class, id);
        return person;
    }
}

PersonRepository .java

public interface PersonRepository extends PersonDao{
    //什么都不需要写
}

测试

    /**
     * 继承抽象类PersonDao并且，创建PersonRepositoryImpl的实现类
     * 注意：该实现类必须以PersonRepository后加Impl作为类名，否则SpringData
     *       无法找到实现类
     * 当PersonRepository调用PersonDao的方法就相当于调用
     * PersonRepositoryImpl的对应的实现方法
     * 
     */
    @Test
    public void testPersonDao(){
        Person p = repository.getMyPersonBy(1);
        System.out.println(p);
    }