spring data jpa总结（一）-一一网

【摘要】 jpa全称Java Persistence Api。在Jpa 中有 JpaRepository 接口，编写接口继承JpaRepository既有crud及分页等基本功能。Jpa可以整合很多技术，Hibernate，Toplink，OpenJpa，而SpringData Jpa的默认实现就是Hibernate。
SpringBoot中Jpa的基本使用
创建项目导入依…

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

SpringBoot中Jpa的基本使用

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

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>

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58

二、创建数据库

打开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;

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

三、创建客户的实体类

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;//客户地址
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55

四、配置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>

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37

五、测试代码

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();

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

当然也可将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(); }
}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

完整代码如下：

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(); }

}

  
 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127
  128
  129
  130
  131
  132
  133
  134
  135
  136
  137
  138
  139
  140
  141
  142
  143
  144
  145
  146
  147
  148
  149
  150
  151
  152
  153
  154
  155
  156
  157
  158
  159
  160
  161
  162
  163
  164
  165
  166
  167
  168
  169
  170
  171
  172
  173
  174
  175
  176
  177
  178
  179
  180
  181
  182
  183
  184
  185