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"