spring data jpa总结（一）

jpa全称Java Persistence Api。在Jpa 中有 JpaRepository 接口，编写接口继承JpaRepository既有crud及分页等基本功能。Jpa可以整合很多技术，Hibernate，Toplink，OpenJpa，而SpringData Jpa的默认实现就是Hibernate。

SpringBoot中Jpa的基本使用

1. 创建项目 导入依赖
2. 编写实体类 添加Jpa注解配置映射关系
3. 编写一个Dao接口来操作实体类对应的数据表（Repository）
4. 配置Jpa
5. 测试类测试

jpa入门

一、导入依赖

<?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>cn.itcast</groupId>
    <artifactId>jpa-day1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>
    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>
        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>
        <!-- log日志 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.12.1</version>
        </dependency>
        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>mysql</groupId>-->
<!--            <artifactId>mysql-connector-java</artifactId>-->
<!--            <version>5.1.37</version>-->
<!--        </dependency>-->
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

二、创建数据库

打开SQLyog，创建jpa数据库,创建一个客户表

 /*创建客户表*/
    CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

三、创建客户的实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
/**
 - 客户的实体类
 -      配置映射关系
 -  4.  5.   1.实体类和表的映射关系
 -      @Entity:声明实体类
 -      @Table : 配置实体类和表的映射关系
 -          name : 配置数据库表的名称
 -   2.实体类中属性和表中字段的映射关系
 -  11.  */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "cst_customer")
public class Customer {
    /**
     * @Id：声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY ：自增，mysql
     *                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *          GenerationType.SEQUENCE : 序列，oracle
     *                  * 底层数据库必须支持序列
     *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
     *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
     * @Column:配置属性和字段的映射关系
     *      name：数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址
}

四、配置JPA的核心配置文件

在java工程的src路径下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件。配置数据库的时候将用户名和密码和数据库的名称改为自己的

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name:持久化单元名称
            transaction-type:事务管理的方式
                JTA:分布式事务管理
                RESOURCE_LOCAL:本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--可选配置：配置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="123456"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>

            <!--配置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" />
        </properties>
    </persistence-unit>
</persistence>

五、测试代码

jpa的操作步骤

• 加载配置文件创建工厂（实体管理类工厂）对象

• 通过实体管理类工厂获取实体管理器

• 开启事务对象，开启事务

• 完成增删改查操作

• 提交事务（回滚事务）

• 释放资源

模板如下

 // 1.加载配置文件创建工厂（实体管理器工厂）对象
 EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
 // 2.通过实体管理器工厂获取实体管理器
 EntityManager em = factory.createEntityManager();
 // 3.获取事务对象，开启事务
 EntityTransaction tx = em.getTransaction();
 tx.begin();// 开启事务
 // 4.完成数据库增删改查操作
 ******
 ******
 // 保存
 em.persist(customer);
 // 5.提交事务
 tx.commit();
 // 6.释放资源
 em.close();
 factory.close();

当然也可将JPA的实体管理器工厂封装成一个工具类

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class JpaUtils {
   //JPA的实体管理器工厂：相当于Hibernate的SessionFactory
    private static EntityManagerFactory factory;
    static {
        // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
        factory = Persistence.createEntityManagerFactory("myJpa");
    }
    /**
     * 获取EntityManager对象
     */
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

完整代码如下：

import cn.itcast.domain.Customer;
import cn.itcast.utils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JpaTest {
    /**
     * 测试jpa的保存
     * 案例：保存一个客户到数据库中
     * jpa的操作步骤
     *      1、加载配置文件创建工厂（实体管理类工厂）对象
     *      2、通过实体管理类工厂获取实体管理器
     *      3、开启事务对象，开启事务
     *      4、完成增删改查操作
     *      5、提交事务（回滚事务）
     *      6、释放资源
     *
     *      persist：保存
     *      merge：更新
     *      remove：删除
     *      find/getrefrence:查询
     *
     */

    @Test
    public void testSave(){
        // 1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        // 保存
        em.persist(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
        factory.close();
    }

    @Test
    public void test01(){
        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        // 保存
        em.persist(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
//        factory.close();

    }

    /**
     * 根据ID查询客户
     * 使用find方法查询：
     *  1、查询的对象就是当前客户对象本身
     *  2、在调用find方法的时候，就会发送sql语句查询数据库
     *立即加载
     *
     *
     */
    @Test
    public void testFind(){

        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作--根据ID查询客户
        /**
         * find:根据ID查询数据
         * class：查询数据的结果需要包装的实体类类型的字节码
         * id:查询的主键的取值
         */
        Customer customer = em.find(Customer.class, 1l);
//        System.out.println(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
    }

    /**
     * 根据ID查询客户
     * getReference方法：
     *  1、获取的对象是一个动态代理对象
     *  2.调用getReference不会立即发送Sql语句查询数据库
     *      *当调用查询结果对象的时候，才会发送查询的SQL语句：什么时候用，什么时候发送SQL语句数据库
     *延迟加载（懒加载
     *     *得到的是一个动态代理对象
     *     *什么时候用，什么使用才会查询
     */
    @Test
    public void testReference(){

        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作--根据ID查询客户
        /**
         * getReference:根据ID查询数据
         * class：查询数据的结果需要包装的实体类类型的字节码
         * id:查询的主键的取值
         */
        Customer customer = em.getReference(Customer.class, 1l);
//        System.out.println(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
    }

    /**
     * 删除客户的案例
     */
    @Test
    public void testRemove(){

        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作--删除客户

        //a、根据ID查询客户
        Customer customer = em.find(Customer.class, 1l);

        //b、调用remove方法完成删除操作
        em.remove(customer);

        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
    }


    /**
     * 更新客户的操作
     * merge更新
     */
    @Test
    public void testUpdate(){

        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作--更新客户操作
        //a、根据ID查询客户
        Customer customer = em.find(Customer.class, 1l);
        //b、更新操作
        customer.setCustIndustry("java开发");
        em.merge(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
    }

}