SpringData

SpringData

一、SpringData概述

二、SpringData JPA HelloWorld

db.properties:

jdbc.user=root
jdbc.password=root
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///jpa?serverTimezone=Asia/Shanghai

Spring配置文件

<?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"
       xmlns:repository="http://www.springframework.org/schema/data/repository"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
        http://www.springframework.org/schema/data/repository http://www.springframework.org/schema/data/repository/spring-repository.xsd
">

    <context:component-scan base-package="com.hmx.springdata"/>

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

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
<!--        配置其他属性-->
    </bean>

<!--   2. 配置EntityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        配置JPA提供商的适配器。 可以通过内部bean 的方式配置-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
        </property>
<!--        配置实体类所在的包-->
        <property name="packagesToScan" value="com.hmx.springdata"/>
<!--        配置JPA的基本属性。 例如 JPA 实现产品的属性-->
        <property name="jpaProperties">
            <props>
<!--                二级缓存相关-->
<!--                <prop key="hibernate.cache.region.factory_class">org.hibernate.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.MySQL8Dialect</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.配置JPA 使用的事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

<!--    4.配置支持基于注解的事务配置-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

<!--    5.配置 SpringData-->
<!--    加入 jpa 的命名空间-->
<!--    base-package: 扫描 Repository Bean 所在的 package-->
    <jpa:repositories base-package="com.hmx.springdata" entity-manager-factory-ref="entityManagerFactory"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>SpringDataJPA</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.3.7.Final</project.hibernate.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
            <version>2.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!--        二级缓存-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${project.hibernate.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>3.6.3</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>jboss-logging</artifactId>
                    <groupId>org.jboss.logging</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>



        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>
    </dependencies>

</project>

package com.hmx.springdata;

import javax.persistence.*;
import java.util.Date;

/**
 * @program: SpringDataJPA2
 * @description:
 * @author: hmx
 * @create: 2021-07-15 21:57
 **/
@Table(name = "JPA_PERSONS")
@Entity
public class Person {

    private Integer id;
    private String lastName;
    private String email;
    private Date birth;
    private Address address;

    @ManyToOne
    @JoinColumn(name = "ADDRESS_ID")
    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                ", birth=" + birth +
                '}';
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }
}

package com.hmx.springdata;

import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;

/**
 * @program: SpringDataJPA2
 * @description:
 * 1. Repository是一个空接口。 即是一个标记接口
 * 2. 若我们定义的接口继承了 Repository，则该接口会被IOC 容器识别为一个 Repository Bean。
 * 纳入到IOC容器中。进而可以在该接口中定义满足一定规范的方法。
 * 3. 实际上，也可以通过@RepositoryDefinition 注解来替代继承Repository 接口
 * @author: hmx
 * @create: 2021-07-15 22:01
 **/
@RepositoryDefinition(domainClass = Person.class,idClass = Integer.class)
public interface PersonRepository /*extends Repository<Person,Integer>*/ {

    /**
     * 根据 lastName 来获取对应的 Person
     * @param lastName
     * @return
     */
    Person getByLastName(String lastName);
}

package com.hmx.springdata.test;

import com.hmx.jpa.service.PersonService;
import com.hmx.springdata.Person;
import com.hmx.springdata.PersonRepository;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.sql.SQLException;

/**
 * @program: SpringDataJPA2
 * @description:
 * @author: hmx
 * @create: 2021-07-15 21:56
 **/
public class SpringDataTest {
    private ApplicationContext ctx = null;

    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void testHelloWorldSpringData(){
        PersonRepository personRepository = ctx.getBean(PersonRepository.class);
        Person person = personRepository.getByLastName("hmx");
        System.out.println(person);
    }

    @Test
    public void testJpa(){

    }


    @Test
    public void testDataSource() throws SQLException {
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());
    }
}

测试:

如果报错：EntityPathResolver must not be null!
要配置 包扫描，使扫描到repository
<!--扫描spring 组件-->
<context:component-scan base-package="com.hmx.springdata"></context:component-scan>

三、 Repository接口

四、 SpringData方法定义规范

 * 在Repository中 子接口中声明方法
 * 1. 不是随便声明的。 而需要符合一定的规范
 * 2. 查询方法以find | read | get 开头
 * 3. 涉及条件查询时，条件的属性用条件关键字连接
 * 4. 要注意的是: 条件属性以首字母大写。
 * 5. 支持属性的级联查询。 若当前类有符合条件的属性，则优先使用，而不是用级联属性。
 * 若需要使用级联属性，则属性之间使用 _ 连接

测试方法1:

@Test
    public void testKeyWords(){
        List<Person> hmx = personRepository.getByLastNameStartingWithAndIdLessThan("hmx", 10);
        System.out.println(hmx);
        
    }

@RepositoryDefinition(domainClass = Person.class,idClass = Integer.class)
public interface PersonRepository /*extends Repository<Person,Integer>*/ {

    /**
     * 根据 lastName 来获取对应的 Person
     * @param lastName
     * @return
     */
    Person getByLastName(String lastName);

    /**
     * WHERE lastName LIKE ?% AND id < ?
     * @param lastName
     * @param id
     * @return
     */
    List<Person> getByLastNameStartingWithAndIdLessThan(String lastName, Integer id);

    /**
     * WHERE lastName LIKE %? AND id < ?
     * @param lastName
     * @param id
     * @return
     */
    List<Person> getByLastNameEndingWithAndIdLessThan(String lastName, Integer id);

    /**
     * WHERE email IN (?,?,?) OR birth < ?
     * @param emails
     * @param birth
     * @return
     */
    List<Person> getByEmailInOrBirthLessThan(List<String> emails, Date birth);

	/**
     * WHERE a.id > ?
     * @param id
     * @return
     */
    List<Person> getByAddress_IdGreaterThan(Integer id);
}

@Test
    public void testKeyWords(){
        List<Person> persons = personRepository.getByLastNameStartingWithAndIdLessThan("hmx", 10);
        System.out.println(persons);
        persons = personRepository.getByLastNameEndingWithAndIdLessThan("hmx", 10);
        System.out.println(persons);
        persons = personRepository.getByEmailInOrBirthLessThan(Arrays.asList("hmx@163.com"), new Date());
        System.out.println(persons);
    }
@Test
    public void testKeyWord2(){
        List<Person> persons = personRepository.getByAddress_IdGreaterThan(1);
        System.out.println(persons);
    }

五、 使用 Query注解

/**
     * 查询id最大的那个Person
     * 使用 @Query 注解可以自定义 JPQL 语句以实现更灵活的查询
     * @return
     */
    @Query("SELECT p From Person p WHERE p.id = (SELECT max(p2.id) FROM Person p2)")
    Person getMaxIdPerson();

@Test
    public void testQueryAnnotation(){
        Person person = personRepository.getMaxIdPerson();
        System.out.println(person);
    }

/**
     * 为 @Query 注解传递参数的方式1: 使用占位符。
     * @param lastName
     * @param email
     * @return
     */
    @Query("SELECT p FROM Person p WHERE p.lastName = ?1 AND p.email = ?2")
    List<Person> testQueryAnnotationParams1(String lastName,String email);

@Test
    public void testQueryAnnotationParams1(){
        List<Person> persons = personRepository.testQueryAnnotationParams1("aa", "aa@163.com");
        System.out.println(persons);
    }

/**
     * 为 @Query 注解传递参数的方式2: 命名参数的方式
     * @param lastName
     * @param email
     * @return
     */
    @Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
    List<Person> testQueryAnnotationParams2(@Param("email") String email,@Param("lastName") String lastName);

@Test
    public void testQueryAnnotationParams2(){
        List<Person> persons = personRepository.testQueryAnnotationParams2("aa@163.com", "aa");
        System.out.println(persons);
    }

/**
     * 允许在命名空间上添加%
     * @param lastName
     * @param email
     * @return
     */
    @Query("SELECT p FROM Person p WHERE p.lastName LIKE %:lastName% OR p.email LIKE %:email%")
    List<Person> testQueryAnnotationLikeParam2(@Param("lastName")String lastName,@Param("email") String email);

    /**
     * 允许在占位符上添加%
     * @param lastName
     * @param email
     * @return
     */
    @Query("SELECT p FROM Person p WHERE p.lastName LIKE %?1% OR p.email LIKE %?2%")
    List<Person> testQueryAnnotationLikeParam(String lastName, String email);

@Test
    public void testQueryAnnotationLikeParam(){
        List<Person> persons = personRepository.testQueryAnnotationLikeParam2("aa", "aa@163.com");
        System.out.println(persons);
    }

/**
     * 设置 nativeQuery=true 即可使用原生的SQL查询
     * @return
     */
    @Query(value = "SELECT count(id) FROM jpa_persons", nativeQuery = true)
    long getTotalCount();

@Test
    public void testNativeQuery(){
        long count = personRepository.getTotalCount();
        System.out.println(count);
    }

六、@Modifying注解和事务

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

@Service
public class PersonService {

    @Autowired
    private PersonRepository personRepository;

    @Transactional
    public void updatePersonEmail(String email, Integer id){
        personRepository.updatePersonEmail(id,email);
    }
}

@Test
    public void testModifying(){
        //personRepository.updatePersonEmail(1,"aaa@163.com");
        personService.updatePersonEmail("aaa@163.com",1);
    }

七、CrudRepository

@Transactional
    public void savePersons(List<Person> persons){
        personRepository.saveAll(persons);
    }

@Test
    public void testCrudRepository(){
        List<Person> persons = new ArrayList<>();
        for(int i = 'a'; i < 'z'; i++){
            Person person = new Person();
            person.setAddressId(i + 1);
            person.setBirth(new Date());
            person.setEmail((char)i + "" + (char)i + "@163.com");
            person.setLastName((char)i + "" + (char)i);
            persons.add(person);
        }

        personService.savePersons(persons);
    }

八、PagingAndSortingRepository

 @Test
    public void testPagingAndSortingRepository(){
        int pageNo = 3;
        int pageSize = 5;
        //Pageable 接口通常使用的其 PageRequest 实现类。 其中封装了需要分页的信息
        //排序相关的。Sort 封装了排序的信息
        //Order 是具体针对于某一个属性进行升序还是降序。
        Sort.Order order1 = new Sort.Order(Sort.Direction.DESC,"id");
        Sort.Order order2 = new Sort.Order(Sort.Direction.ASC,"email");

        Sort sort = Sort.by(order1,order2);
        PageRequest pageable = PageRequest.of(pageNo, pageSize,sort);
        Page<Person> page = personRepository.findAll(pageable);

        System.out.println("总记录数: " + page.getTotalElements() );
        System.out.println("当前页码: " + page.getNumber());
        System.out.println("总页数: " + page.getTotalPages());
        System.out.println("当前页面的List: " + page.getContent());
        System.out.println("当前页面的记录数: " + page.getNumberOfElements());
    }

其中PageReuqest的构造方法由protected修饰，只能由其of方法返回一个 PageRequest对象
其中Sort的构造方法由private或protected修饰, 只能由其by方法返回一个Sort对象

九、JpaRepository

@Test
    public void testJpaRepository(){
        Person person = new Person();
        person.setBirth(new Date());
        person.setEmail("XYZ@163.com");
        person.setLastName("xyz");
        person.setId(28);

        Person person2 = personRepository.saveAndFlush(person);
        System.out.println(person2);
    }

十、JpaSpecificationExecutor接口

/**
     * 目标: 实现带查询条件的分页。id > 5 的条件
     * 调用 JpaSpecificationExecutor 的 Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);
     * Specification: 封装了 JPA Criteria 查询的查询条件
     * Pageable: 封装了请求分页的信息: 例如 pageNo, pageSize, Sort
     */
    @Test
    public void testJpaSpecificationExecutor(){
        int pageNo = 2;
        int pageSize = 5;
        PageRequest pageRequest = PageRequest.of(pageNo, pageSize);

        //通常使用 Specification 的匿名内部类
        Specification<Person> specification = new Specification<Person>() {

            /**
             *
             * @param root 代表查询的实体类
             * @param criteriaQuery 可以从中得到 Root对象， 及告知 JPA Criteria 查询要查询哪一个实体类。 还可以来添加
             *                      查询条件， 还可以结合 EntityManager 对象得到最终查询的 TypedQuery对象。
             * @param criteriaBuilder CriteriaBuilder对象。用于创建Criteria 相关对象的工厂。 当然可以从中获取到Predicate对象
             * @return Predicate类型，代表一个查询条件
             */
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path path = root.get("id");
                Predicate predicate = criteriaBuilder.gt(path,5);
                return predicate;
            }
        };

        Page<Person> page = personRepository.findAll(specification, pageRequest);

        System.out.println("总记录数: " + page.getTotalElements() );
        System.out.println("当前页码: " + page.getNumber() + 1);
        System.out.println("总页数: " + page.getTotalPages());
        System.out.println("当前页面的List: " + page.getContent());
        System.out.println("当前页面的记录数: " + page.getNumberOfElements());
    }

十一、自定义Repository方法

public interface PersonDao {
    void test();
}

public class PersonRepositoryImpl implements PersonDao {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public void test() {
        Person person = entityManager.find(Person.class, 18);
        System.out.println(person);
    }
}

@Test
    public void testCustomerRepositoryMethod(){
        personRepository.test();
    }