SpringData JPA学习笔记

为什么要用SpringData？

主要用于实现数据存储的，目前单一的关系型数据库已经无法满足现在的需求了，现在会有不同的存储方案来实现不同的场景

        我们需要一种技术来实现统一的存储方式的实现，SpringData提供了模板对象供我们非常方便简单的实现不同数据存储的数据操作。SpringData统一了数据访问层。

什么是JPA？

相同处：

1.都跟数据∙库操作有关，JPA 是JDBC 的升华，升级版。

2.JDBC和JPA都是一组规范接口

3.都是由SUN官方推出的

不同处：

1.JDBC是由各个关系型数据库实现的， JPA 是由ORM框架实现 （数据库的表跟类关系映射上）

2.JDBC 使用SQL语句和数据库通信。 JPA用面向对象方式， 通过ORM框架来生成SQL，进行操作（最后还是要用JDBC去操作数据库）。

3.JPA在JDBC之上的， JPA也要依赖JDBC才能操作数据库。

JDBC是我们最熟悉的用来操作数据库的技术，但是随之而来带来了一些问题：

1. 需要面向SQL语句来操作数据库，开发人员学习成本更高。

2. 数据库的移植性不高，不同数据库的SQL语句无法通用。

3. java对象和数据库类型的映射是个麻烦事。

但在Sun在JDK1.5提出了JPA：

JPA全称Java Persistence API（2019年重新命名为 Jakarta Persistence API ），是Sun官方提出的一种ORM规范。 O:Object R: Relational M:mapping

作用

1.简化持久化操作的开发工作：让开发者从繁琐的 JDBC 和 SQL 代码中解脱出来，直接面向对象持久化操作。

2.Sun希望持久化技术能够统一，实现天下归一：如果你是基于JPA进行持久化你可以随意切换数据库。

该规范为我们提供了：

1）ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对

象持久化到数据库表中；

如：@Entity 、 @Table 、@Id（是不是主键id） 与 @Column(属性是不是列名)等注解。

2）JPA 的API：用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和 SQL代码中解脱出来。

如：entityManager.merge(T t)；

3）JPQL查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

如：from Student（类名） s where s.name = ?  （属性名），面向对象的方式

So: JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的。

Hibernate与JPA:所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。

也就是说：

JPA是一套ORM规范，Hibernate实现了JPA规范，Hibernate实现了JPA,再结合ORM映射生成SQL语句，再去调用JDBC操作数据库

半自动的ORM框架，

小巧： mybatis就是jdbc封装 在国内更流行。

场景： 在业务比较复杂系统进行使用

hibernate：强大、方便、高效、（简单）复杂、绕弯子、全自动

全自动的ORM框架，

强大：根据ORM映射生成不同SQL 在国外更流行。

场景： 在业务相对简单的系统进行使用，随着微服务的流行。

hibernate可以不用设计表的，Code First ，只需要专注于编码，通过实体类去生成表。

创建实体类：

package com.xie.pojo;

import javax.persistence.*;

/**
 * @Author xiehu
 * @Date 2022/10/3 21:56
 * @Version 1.0
 * @Description
 */
@Entity  //作为hibernate的实例
@Table(name = "tb_customer")  //映射的表名 会生成表
public class Customer {
    @Id //主键
    /**
     * 主键的生成策略 ：
     *     SEQUENCE ：序列，oracle 底层数据库必须支持序列
     *     IDENTITY：自增，mysql 底层数据库必须支持自动增长（对id自增）
     *     AUTO： 由程序自动的帮助我们选择主键生成策略
     */
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="cust_id") //对应的数据库字段名字
    private Long custId;  //主键

    @Column(name="cust_name")
    private String custName;

    @Column(name = "cust_address")
    private String custAddress;

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }
public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custAddress='" + custAddress + '\'' +
                '}';
    }

新建xml资源文件，文件名最好是：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>

        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://127.0.0.1:3306/springdata_jpa?characterEncoding=UTF-8</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- 允许显示sql语句,会在日志中记录sql,生产环境可能造成日志偏多-->
        <property name="show_sql">true</property>
        <!-- 是否格式化sql 默认false-->
        <property name="format_sql">true</property>
        <!--表生成策略
            默认 none 不自动生成
            update 如果没有表会创建，有会检查更新
            create 都会创建-->
        <property name="hbm2ddl.auto">update</property>
        <!-- 配置方言：选择数据库类型
            搜 dialect类，Ctrl+H 查看用哪种，复制完整限定名来使用-->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!--        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>-->
        <!-- 映射方式,指定哪些实体类需要映射-->
        <mapping class="com.xie.pojo.Customer"></mapping>
<!--        <mapping class="com.xie.pojo.User"></mapping>-->
<!--        <mapping class="com.xie.pojo.Wife"></mapping>-->
<!--        <mapping class="com.xie.pojo.Hobby"></mapping>-->
    </session-factory>

</hibernate-configuration>

测试案例  插入数据

public class HibernateTest {

    // Session工厂  Session:数据库会话  代码和数据库的一个桥梁
    private SessionFactory sf;
    //需要通过读取识别配置文件去构建解析
    @Before
    public void init() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate.cfg.xml").build();

        //2. 根据服务注册类创建一个元数据资源集，同时构建元数据并生成应用一般唯一的的session工厂

        sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();
    }
    //插入的操作
    @Test
    public void testC(){
        // session进行持久化操作 用try 包裹session 最后会自动关闭
        try(Session session = sf.openSession()){
            //开启事务
            Transaction tx = session.beginTransaction();

            Customer customer = new Customer();
            customer.setCustName("张三");
            customer.setCustAddress("天府三街");
            //基于对象 将数据保存起来
            session.save(customer);
            //提交事务
            tx.commit();
        }

    }

查询

@Test
public void testR(){
    // session进行持久化操作
    try(Session session = sf.openSession()){
        Transaction tx = session.beginTransaction();
        //查询 直接查询出来
        Customer customer = session.find(Customer.class,1L);
        System.out.println("=====================");
        System.out.println(customer);

        tx.commit();
    }

}

@Test
public void testR_lazy(){
    // session进行持久化操作
    try(Session session = sf.openSession()){
        Transaction tx = session.beginTransaction();
        //load 会进行懒加载 什么时候用到才会进行查询
        Customer customer = session.load(Customer.class, 1L);
        System.out.println("=====================");
        //此时用到了，才会执行查询操作
        System.out.println(customer);

        tx.commit();
    }

}

 更新

@Test
public void testU(){
    // session进行持久化操作
    try(Session session = sf.openSession()){
        Transaction tx = session.beginTransaction();

        Customer customer = new Customer();
        //customer.setCustId(1L); 指定id
        customer.setCustName("李四");
        // 插入session.save()
        // 更新session.update();
        //如果存在会进行更新，如果不存在会新增 比如对象存在 主键id
        session.saveOrUpdate(customer);
        tx.commit();
    }

}

删除

//删除
@Test
public void testD(){
    // session进行持久化操作
    try(Session session = sf.openSession()){
        Transaction tx = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCustId(2L);
        session.remove(customer);

        tx.commit();
    }
}

JPQL的基础上进行了 扩展，HQL更加强大

@Test
public void testR_HQL(){
    // session进行持久化操作
    try(Session session = sf.openSession()){
        Transaction tx = session.beginTransaction();
        //声明一个HQL 省略了[select] from +类名 +where +属性名
        String hql=" FROM Customer where custId=:id";
        //第一个参数 hql ,第二个参数为返回类型
        List<Customer> resultList = session.createQuery(hql, Customer.class)
                //参数名字“id" ,值
                .setParameter("id",1L)
                .getResultList();
        System.out.println(resultList);
        tx.commit();
    }
}

如果单独使用hibernate的API来进行持久化操作，则不能随意切换其他ORM框架

使用jpa 就可以随意切换各种实现

Jpa示例

1.添加

META-INF\persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<!--<persistence version="2.2"-->
<!--             xmlns="http://xmlns.jcp.org/xml/ns/persistence"-->
<!--             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"-->
<!--             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence-->
<!--     http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">-->

    <!--    需要配置persistence‐unit节点 单元
    持久化单元：可以为hibernate 或者openJPA配置一个持久化单元 需要换哪个实现 就去拿那个name
    name：持久化单元名称
    transaction‐type：事务管理的方式
    JTA：分布式事务管理
     RESOURCE_LOCAL：本地事务管理 -->
    <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
        <!-- 代表的你是哪一个 jpa的实现 这里是hibernate 如果有多个可加一个持久化单元-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!-- 需要进行ORM的POJO类 完整限定名-->
        <class>com.xie.pojo.Customer</class>
        <!--    可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!--    数据库信息-->
            <!--        用户名，javax.persistence.jdbc.user-->
            <!--        密码， javax.persistence.jdbc.password -->
            <!--        驱动， javax.persistence.jdbc.driver -->
            <!--        数据库地址 javax.persistence.jdbc.url -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url"
                      value="jdbc:mysql://localhost:3306/springdata_jpa?serverTimezone=UTC"/>
            <!--配置jpa实现方(hibernate)的配置信息
            显示sql ： false|true
            自动创建数据库表 ： hibernate.hbm2ddl.auto
            create : 程序运行时创建数据库表（如果有表，先删除表再创建）
            update ：程序运行时创建表（如果有表，不会创建表）
            none ：不会创建表-->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
        </properties>
    </persistence-unit>
</persistence>

JPA测试代码：

public class JpaTest {
    EntityManagerFactory factory;
    //配置文件的读取解析
    @Before
    public void before(){
        //指定持久化单元的名称 用的哪种JPA实现方式的单元名,也可以多一个入参，来设置配置项，这里使用配置文件中的内容所以只有一个参数
        factory= Persistence.createEntityManagerFactory("hibernateJPA");
    }
    //插入
    @Test
    public void testC(){
        //相当于hibernate的session，桥梁
        EntityManager entityManager = factory.createEntityManager();
        //得到事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        Customer customer = new Customer();
        customer.setCustName("张三");

        entityManager.persist(customer);
        tx.commit();
    }

新增openJPA的实现

<!--增加一个openJPA依赖-->
<dependency>
    <groupId>org.apache.openjpa</groupId>
    <artifactId>openjpa-all</artifactId>
    <version>3.2.0</version>
</dependency>

<!--openJPA 单元实现-->
    <persistence-unit name="openJPA" transaction-type="RESOURCE_LOCAL">
        <!-- 代表的你是哪一个 jpa的实现 这里是openJPA 如果有多个可加一个持久化单元-->
        <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
        <!-- 需要进行ORM的POJO类 完整限定名-->
        <class>com.xie.pojo.Customer</class>
        <!--    可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!--    数据库信息-->
            <!--        用户名，javax.persistence.jdbc.user-->
            <!--        密码， javax.persistence.jdbc.password -->
            <!--        驱动， javax.persistence.jdbc.driver -->
            <!--        数据库地址 javax.persistence.jdbc.url -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url"
                      value="jdbc:mysql://localhost:3306/springdata_jpa?serverTimezone=UTC"/>
            <!-- 自动生成数据库表-->
            <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
        </properties>

测试代码：

需要更换实现只需要 修改 factory即可

public class JpaTest {
    EntityManagerFactory factory;

    //配置文件的读取解析
    @Before
    public void before() {
        //指定持久化单元的名称 用的哪种JPA实现方式的单元名,也可以多一个入参，来设置配置项，这里使用配置文件中的内容所以只有一个参数
        factory = Persistence.createEntityManagerFactory("hibernateJPA");
//        factory= Persistence.createEntityManagerFactory("openJPA");
    }

    //插入
    @Test
    public void testC() {
        //相当于hibernate的session，桥梁
        EntityManager entityManager = factory.createEntityManager();
        //得到事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        Customer customer = new Customer();
        customer.setCustName("张三");

        entityManager.persist(customer);
        tx.commit();
    }

    //查询 立即查询
    @Test
    public void testR() {
        EntityManager em = factory.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        Customer customer = em.find(Customer.class, 2L);
        System.out.println(customer);

        tx.commit();
    }

    //延时加载
    @Test
    public void testLazy() {
        EntityManager em = factory.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();
        Customer customer = em.getReference(Customer.class, 1L);
        System.out.println("=======================");
        System.out.println(customer);
        tx.commit();
    }

    //修改
    @Test
    public void testU() {
        EntityManager em = factory.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        Customer customer = new Customer();
        customer.setCustName("王五");
        customer.setCustId(5L);
        //根据这个id先查询是否有这条记录，如果有变化，就会更新，如果把id 注释掉，会直接插入
        em.merge(customer);
        //不会先查询，直接会将id为5的进行更新
        String jpql = "UPDATE Customer set custName=:Name where custId=:id";
        em.createQuery(jpql)
                .setParameter("Name","李四")
                .setParameter("id",5L)
                .executeUpdate();
        //如果很复杂也可以直接用 SQL ,用表名，列名字段
        String sql = "UPDATE tb_customer set cust_name=:Name where id=:id";
        em.createNamedQuery(sql)
                .setParameter("Name","王五")
                .setParameter("id",4L)
                .executeUpdate();

        tx.commit();
    }
    //删除
    @Test
    public void testD(){
        EntityManager em = factory.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
//        Customer customer = new Customer();
//        customer.setCustId(5L);
        Customer customer = em.find(Customer.class, 5L);
        //只能删除持久化状态的对象,由于是自己new的对象，且数据库此id的对象已经有来了，此时是游离状体， 所以要先查询出来表示是持久状态 再删
        em.remove(customer);
        tx.commit();
    }
//一级缓存 测试
@Test
public void testCacheI(){
    EntityManager em = factory.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //这里只会查一次
    Customer customer = em.find(Customer.class, 1L);
    Customer customer2 = em.find(Customer.class, 1L);

    tx.commit();
}

}

 jpa的对象4种状态

临时状态：刚创建出来，∙没有与entityManager发生关系，没有被持久化，不处于entityManager中的对象

持久状态：∙与entityManager发生关系，已经被持久化，您可以把持久化状态当做实实在在的数据库记录。

删除状态：执行remove方法，事物提交之前

游离状态：游离状态就是提交到数据库后，事务commit后实体的状态，因为事务已经提交了，此时实体的属 性任你如何改变，也不会同步到数据库，因为游离是没人管的孩子，不在持久化上下文中

什么是spring data jpa ?

        旨在改进数据访问层的实现以提升开发效率，spring data jpa 是spring 提供的一套简化JPA开发的框架（目前实现jpa的框架都会有一些重复代码），按照约定好的规则进行方法命名去写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作

        一般使用Spring Data JPA+ORM(hibernate)完成操作。在切换不同的ORM框架时提供了极大的方便，使数据库层操作更加简单。

Spring Data JPA实例

1.最好在父maven项目中设置spring data统一版本管理依赖: 因为不同的spring data子项目发布时间版本不一样，你自 己维护很麻烦， 这样不同的spring data子项目能保证是统一版本

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-bom</artifactId>
            <version>2021.1.2</version>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

SpringDataJpa搭建Xml的配置方式

依赖

<!--junit4-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>
<!--hibernate对jpa的支持包-->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>5.6.11.Final</version>
</dependency>
<!--Mysql and MariaDB-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>
<!-- 连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.21</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.22</version>
    <scope>test</scope>
</dependency>

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

    <!--用于整合jpa  需要一个数据访问层的包-->
    <jpa:repositories base-package="com.xie.repositories"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"/>
    <!--entityManagerFactory-->
    <bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--持久化单元里的属性配置-->
        <property name="jpaVendorAdapter">
            <!--Hibernate 实现-->
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--生成数据库表，生产一般不需要重复创建-->
                <property name="generateDdl" value="true"></property>
                <property name="showSql" value="true"></property>
            </bean>
        </property>
        <!--设置扫描实体类的包 哪些类要进行ORM映射-->
        <property name="packagesToScan" value="com.xie.pojo"></property>
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean class="com.alibaba.druid.pool.DruidDataSource" name="dataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"></property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
<!--声明事务-->
    <bean class="org.springframework.orm.jpa.JpaTransactionManager" name="transactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>
<!--事务使用方式 启动注解方式的声明式事务-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

 Xml方式测试

/基于junit4 spring单元测试
@ContextConfiguration(locations = "/spring.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJpaTest {
    @Autowired
    CustomerRepository repository;

    //查询
    @Test
    public void testR() {
        Optional<Customer> byId = repository.findById(1L);
        System.out.println(byId.get());
    }

    //插入
    @Test
    public void testC() {
        Customer customer = new Customer();
        //  customer.setCustId(1l); 如果有id 则会进行更新 会先查询
        customer.setCustName("李四");
        repository.save(customer);
        // 底层会先查一遍 再删除
        repository.delete(customer);
    }
}

 配置类的方式：