springDataJPA笔记
第一 orm思想
主要目的：操作实体类就相当于操作数据库表
建立两个映射关系：
实体类和表的映射关系
实体类中属性和表中字段的映射关系
不再重点关注：sql语句
实现了ORM思想的框架：mybatis，hibernate
第二 hibernate框架介绍
Hibernate是一个开放源代码的对象关系映射框架，
它对JDBC进行了非常轻量级的对象封装，
它将POJO与数据库表建立映射关系，是一个全自动的orm框架
第三 JPA规范
jpa规范，实现jpa规范，内部是由接口和抽象类组成
第四 jpa的基本操作
案例：是客户的相关操作（增删改查）
客户：就是一家公司
客户表：
jpa操作的操作步骤
1.加载配置文件创建实体管理器工厂
Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
createEntityMnagerFactory（持久化单元名称）
作用：创建实体管理器工厂
2.根据实体管理器工厂，创建实体管理器
EntityManagerFactory ：获取EntityManager对象
方法：createEntityManager
* 内部维护的很多的内容
内部维护了数据库信息，
维护了缓存信息
维护了所有的实体管理器对象
再创建EntityManagerFactory的过程中会根据配置创建数据库表
* EntityManagerFactory的创建过程比较浪费资源
特点：线程安全的对象
多个线程访问同一个EntityManagerFactory不会有线程安全问题
* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
思路：创建一个公共的EntityManagerFactory的对象
* 静态代码块的形式创建EntityManagerFactory
3.创建事务对象，开启事务
EntityManager对象：实体类管理器
beginTransaction : 创建事务对象
presist ： 保存
merge ： 更新
remove ： 删除
find/getRefrence ： 根据id查询
Transaction 对象 ： 事务
begin：开启事务
commit：提交事务
rollback：回滚
4.增删改查操作
5.提交事务
6.释放资源
i.搭建环境的过程
1.创建maven工程导入坐标
2.需要配置jpa的核心配置文件
*位置：配置到类路径下的一个叫做 META-INF 的文件夹下
*命名：persistence.xml
3.编写客户的实体类
4.配置实体类和表，类中属性和表中字段的映射关系
5.保存客户到数据库中
ii.完成基本CRUD案例
persist ： 保存
merge ： 更新
remove ： 删除
find/getRefrence ： 根据id查询
iii.jpql查询
sql：查询的是表和表中的字段
jpql：查询的是实体类和类中的属性
* jpql和sql语句的语法相似
1.查询全部
2.分页查询
3.统计查询
4.条件查询
5.排序
以上是课件的内容：
总结：
使用jpa的步骤，但是不适用springboot注解的形式，那么
第一步就需要创建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>
<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.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///springdatajpa"/>
<!--可选的配置：为了配置jpa实现方的配置信息
hibernate:
显示sqlhibernate.show_sql
自动创建数据库表hibernate.hbm2ddl.auto
create:程序运行时创建数据库表（如果有表，先删除表再创建）
update：c程序运行时创建表（如果有表不会创建表）
none：不会创建表
-->
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
以上的代码进行了详细的注解，就不需要解释了。
第二步：需要创建实体类，根据实体类进行创建数据库表结构：
package cn.itcast.domain;
/**
* @Created by Intellij IDEA.
* @author: 陈亚萌
* @Date: 2020/1/18
*/
import javax.persistence.*;
/**
* 客户实体类：
* 配置映射关系：
* 1. 实体类和表的映射关系
* 2. 实体类中属性和表中字段的映射关系
* @Entity声明实体列
* @Table：声明实体类和表的映射关系 name 属性是配置数据库的名称
* @Id：声明主键
* strategy
* @GeneratedValue(strategy = GenerationType.IDENTITY) 表示主键生成策略是自增 mysql
* * 底层数据库必须支持自动增长，底层数据库支持的自动增长方式，对id递增
* GenerationType.SEQUENCE： 序列 Oracle
* 底层数据库必须支持序列
* GenerationType.TABLE ：
* jpa提供的一种机制，通过数据库表的形式帮我们完成主键自增
* GenerationType.AUTO:
* 由程序自动帮我们选择主键生成策略
* @Column(name = 'cust_id')配置属性和字端的映射关系 name代表数据库表中的字段名
*/
@Entity
@Table(name = "cst_customer")
public class Customer {
@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;
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName='" + custName + '\'' +
", custSource='" + custSource + '\'' +
", custLevel='" + custLevel + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custPhone='" + custPhone + '\'' +
", custAddress='" + custAddress + '\'' +
'}';
}
}
以上也有对每段代码的详细注解，也可以不用手写setget方法，直接使用lombok进行@Data注解即可。
第三步，进行测试：
package cn.itcast;
import cn.itcast.domain.Customer;
import cn.itcast.utils.JpaUtils;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
/**
* @Created by Intellij IDEA.
* @author: 陈亚萌
* @Date: 2020/1/18
*/
public class test {
/*
* 测试jpa的保存
* 案例 保存一个客户到数据库
* jpa操作步骤：
* 1. 加载配置文件创建工厂（实体管理工厂）对象
* 2. 通过实体管理类获取实体管理器
* 3. 获取事务对象，开启事务
* 4. 完成增删改查操作
* 5. 提交事务（回滚事务）
* 6. 释放资源
* */
@Test
public void testSave(){
/* //1. 加载配置文件创建工厂（实体管理工厂）对象
EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
//2. 通过实体管理类获取实体管理器
EntityManager em = factory.createEntityManager();*/
EntityManager em= JpaUtils.getEntityManager();
// 3 . 获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
//开启事务
tx.begin();
//4。完成增删改查操作
Customer customer=new Customer();
customer.setCustName("chenyameng");
customer.setCustIndustry("IT");
//保存
em.persist(customer);
// 5. 提交事务（回滚事务）
tx.commit();
// 6. 释放资源
em.close();
//factory.close();
}
/**
* 根据id查询用户
*/
@Test
public void testFind(){
//1, 通过工具类获取entityManger
EntityManager em = JpaUtils.getEntityManager();
//2，开启事务
EntityTransaction tx=em.getTransaction();
tx.begin();
//3， 增删改查
/**
* find：根据id查询数据
* class：字节码，查询数据的结果需要包装的实体类类型的字节码
* id：查询的主键的取值
*
* 使用find方法查询
* 1. 查询的对象就是当前客户对象本身
* 2. 调用find方法的时候，就会发送sql请求
*/
Customer customer = em.find(Customer.class, 1l);
System.out.println(customer.toString());
//4，提交事务，
tx.commit();
// 释放资源
em.close();
}
/**
* 根据id查询用户
*/
@Test
public void testReference(){
//1, 通过工具类获取entityManger
EntityManager em = JpaUtils.getEntityManager();
//2，开启事务
EntityTransaction tx=em.getTransaction();
tx.begin();
//3， 增删改查
/**
* getReference：根据id查询数据
* class：字节码，查询数据的结果需要包装的实体类类型的字节码
* id：查询的主键的取值
*
* 特点：
* 获取的对象是动态代理的对象
* 调用reference方法不会立即发送sql语句查询数据库
* * 当调用查询结果的时候，才会发送sql语句，什么时候用，什么时候发送sql语句
* 延迟加载，特点：
* 得到的是动态代理对象
* 什么时候用什么时候查
*
*/
Customer customer = em.getReference(Customer.class, 1l);
System.out.println(customer.toString());
//4，提交事务，
tx.commit();
// 释放资源
em.close();
}
/**
* s删除客户
*/
@Test
public void testRemove(){
//1, 通过工具类获取entityManger
EntityManager em = JpaUtils.getEntityManager();
//2，开启事务
EntityTransaction tx=em.getTransaction();
tx.begin();
//3， 增删改查
//3.1 根据id查询客户
final Customer customer = em.find(Customer.class, 1L);
// 3.2 调用remove 方法删除操作
em.remove(customer);
//4，提交事务，
tx.commit();
// 释放资源
em.close();
}
/**
* 更新客户
*/
@Test
public void testUpdate(){
//1, 通过工具类获取entityManger
EntityManager em = JpaUtils.getEntityManager();
//2，开启事务
EntityTransaction tx=em.getTransaction();
tx.begin();
//3， 增删改查
//3.1 客户的更新
final Customer customer = em.find(Customer.class, 2L);
customer.setCustIndustry("it教育");
// 3.2 调用update
em.merge(customer);
//4，提交事务，
tx.commit();
// 释放资源
em.close();
}
}
以上代码也有详细的解释。
jqpl语言的简单讲解：
package cn.itcast;
import cn.itcast.utils.JpaUtils;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;
/**
* @Created by Intellij IDEA.
* @author: 陈亚萌
* @Date: 2020/1/18
* jpql测试
*/
public class JpqlTest {
/**
* 查询全部：
* jqpl：from cn.itcast.domain.Customer
* sql：select * from cst_customer
*/
@Test
public void testFindAll(){
//1， 获取Entitymanager对象
EntityManager em=JpaUtils.getEntityManager();
//2 开启事务
final EntityTransaction transaction = em.getTransaction();
transaction.begin();
//3 查询全部
String jpql="from Customer";
//创建Query对象，query对象才是执行spql对象
Query query = em.createQuery(jpql);
//发送查询，并封装结果集
List list = query.getResultList();
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// 4.提交事务
transaction.commit();
// 释放资源
em.close();
}
/**
* 排序查询：
* jqpl：from cn.itcast.domain.Customer order by custId
* sql：select * from cst_customer order by cust_id DESC
* 进行jpql查询：
* 1. 创建query对象
* 2. 对参数进行复制
* 3. 查询并返回结果
*/
@Test
public void testOrder(){
//1， 获取Entitymanager对象
EntityManager em=JpaUtils.getEntityManager();
//2 开启事务
final EntityTransaction transaction = em.getTransaction();
transaction.begin();
//3 查询全部
String jpql="from cn.itcast.domain.Customer order by custId DESC";
//创建Query对象，query对象才是执行spql对象
Query query = em.createQuery(jpql);
//发送查询，并封装结果集
List list = query.getResultList();
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// 4.提交事务
transaction.commit();
// 释放资源
em.close();
}
/**
* 计数查询：
*
* 使用jpql查询，统计客户的总数：
* sql：select count（cus_id） from customer
* jpql:select count(custId) from Customer
*/
@Test
public void testCount(){
//1， 获取Entitymanager对象
EntityManager em=JpaUtils.getEntityManager();
//2 开启事务
final EntityTransaction transaction = em.getTransaction();
transaction.begin();
//3 查询全部
//1 根据jpql语句创建query对象
String jpql="select count(custId) from Customer";
//2 参数赋值
// 3 发送查询，并封装结果
Query query = em.createQuery(jpql);
//发送查询，并封装结果集
/**
* getResultList：直接将查询结果封装成为list集合
* getSingleResult：得到唯一的结果集
*/
final Object singleResult = query.getSingleResult();
System.out.println(singleResult);
// 4.提交事务
transaction.commit();
// 释放资源
em.close();
}
/**
* 分页查询：
* sql：select * from cst_customer limit ?,?
* jpql:from Customer
*/
@Test
public void testPage(){
//1， 获取Entitymanager对象
EntityManager em=JpaUtils.getEntityManager();
//2 开启事务
final EntityTransaction transaction = em.getTransaction();
transaction.begin();
//3 查询全部
//1 根据jpql语句创建query对象
String jpql="from Customer";
// 3 发送查询，并封装结果
Query query = em.createQuery(jpql);
//发送查询，并封装结果集
/**
* getResultList：直接将查询结果封装成为list集合
* getSingleResult：得到唯一的结果集
*/
final List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
//2 参数赋值
//起始索引，
query.setFirstResult(0);
//每页查询的条数
query.setMaxResults(2);
// 4.提交事务
transaction.commit();
// 释放资源
em.close();
}
/**
* 条件查询：
* 查询客户名称以“传值”开头的
* sql: select * from cst_customer where cust_name like '搜索%'
* jpql： from Customer where custName like ?
*/
@Test
public void testCondition(){
//1， 获取Entitymanager对象
EntityManager em=JpaUtils.getEntityManager();
//2 开启事务
final EntityTransaction transaction = em.getTransaction();
transaction.begin();
//3 查询全部
//1 根据jpql语句创建query对象
String jpql="from Customer where custName like ?";
// 3 发送查询，并封装结果
Query query = em.createQuery(jpql);
//发送查询，并封装结果集
/**
* getResultList：直接将查询结果封装成为list集合
* getSingleResult：得到唯一的结果集
*/
//2 参数赋值 占位符参数
// 第一个参数： 占位符的索引位置：（从1开始） 第二个参数：取值
final Query query1 = query.setParameter(1, "chenya%");
final List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
// 4.提交事务
transaction.commit();
// 释放资源
em.close();
}
}
这种方法一般不常用，常用的是已经封装好的，但是底层源码应该就是这样的，初步理解，如果错误，指出更正。
代码上传到git：
"springdatajpa"
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
