SpringDataJpa学习(一) orm思想和hibernate以及jpa的概述和jpa的基本操作
-
第一 ORM思想
传统的jdbc对数据库的操作
主要目的：操作实体类就相当于操作数据库表。
建立两个映射关系：
实体类和表的映射关系 实体类中属性和表中字段的关系好处：不再重点关注sql语句。
实现了ORM思想的框架：mybatis,hibernate
-
第二 hibernate框架介绍
概述：
Hibernate是一个开放源代码的对象关系映射框架。它对jdbc进行了非常轻量级的对象封装，它将POJO与数据表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成sql语句，自动执行，使得java程序员可以随心所欲的使用对象编程思维来操作数据库 -
第三 JPA规范
JPA概述：
JPA全称是Java Persistence API,即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层
JPA（Java持久化API）是一种Java应用程序接口规范，描述java应用中关系数据的管理，充当面向对象的领域模型和关系数据库系统之间的桥梁。
Application code —> JPA ---->实现JPA规范的框架（比如hibernate、spring data jpa） ----> 数据库
graph LR
A[Application code] --> |jpa规范| B(hibernate)
B -->|jdbc| C(mysql数据库)
-
第四 JPA的基本操作
案例：对客户的相关操作（增删查改）客户：就是一家公司 客户表：cst_customer
i:环境搭建
1.创建maven工程导入坐标
<?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.ysk</groupId>
<artifactId>jap-day1</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.4.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>5.4.5.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
</dependencies>
</project>
2.需要配置jpa的核心配置文件
*配置到类路径下的一个叫做 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 事务管理方式
JPA:分布式事务管理
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.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///mytest"/>
<!--配置jpa实现方(hibernate)的配置信息
显示sql ： hibernate.show_sql : false|true
自动创建数据库表：hibernate.hbm2ddl.auto :
create : 程序运行时创建数据表，如果有表，先删除再创建
update : 程序运行时创建表，如果有表，不会创建表
none : 不会创建表
-->
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="create"/>
</properties>
</persistence-unit>
</persistence>
3.编写客户的实体
4.配置实体类和表，类中属性和表中字段的映射关系
package cn.ysk.domain;
import javax.persistence.*;
/**
* 客户实体类
* 配置映射关系
* 1.实体类和表的映射关系
* @Entity 声明实体类
* @Table 配置实体类和表的映射关系
* name：配置数据库表的名称
* 2.实体类中属性和表中字段的映射关系
* @Id 声明主键的配置
* @GeneratedValue 配置主键的生成策略
* GenerationType.IDENTITY 自增
* @Column 配置属性和字段的映射关系
* name 数据库表中字段的名称
*
*
* @Author ysk
* @Date 2020/3/5 21:21
* @Version 1.0
*/
@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 Customer() {
}
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 + '\'' +
'}';
}
}
5.完成第一个操作，保存客户数据到数据库中
/**
* Jpa的操作步骤
* 1.加载配置文件创建工厂对象（实体管理类工厂）
* Persistence:静态方法（根据持久化单元名称创建实体管理器工厂）
* createEntityManagerFactory(”持久化单元名称“)
* 2.通过实体管理类工厂获取实体管理器
* createEntityManager : 获取EntityManager对象
* 方法:createEntityManager
* * 内部维护了很多的内容
* 维护了数据库信息
* 维护了缓存信息
* 维护了所有实体管理器对象
* 再创建EntityManagerFactory的过程中会根据配置创建数据库表
* * EntityManagerFactory的创建过程比较浪费资源
* 特点：线程安全的对象
* 释：多个线程访问一个EntityManagerFactory不会有线程安全问题
* * 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
* 思路：创建一个公共的EntityManagerFactory的对象
* * 静态代码块的形式创建EntityManagerFactory
*
* 3.获取事务对象，开启事务
* EntityManager对象：实体类管理器
* beginTransaction : 创建事务对象
* persist : 保存
* merge : 更新
* remove : 删除
* find/getRefrence : 根据id查询
* Transaction 对象 :事务
* begin:开启事务
* commit:提交事务
* rollback:回滚
* 4.完成增城改查操作
* 对的
* 5.提交事务（抛出异常时，回滚事务）
* 6.释放资源
*/
package cn.ysk.test;
import cn.ysk.domain.Customer;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
/**
* @Author ysk
* @Date 2020/3/5 21:40
* @Version 1.0
*/
public class JpaTest {
/**
* 测试jpa的保存
* 案例：保存一个客户到数据表中
* Jpa的操作步骤
* 1.加载配置文件创建工厂对象（实体管理类工厂）
* 2.通过实体管理类工厂获取实体管理器
* 3.获取事务对象，开启事务
* 4.完成增城改查操作
* 5.提交事务（抛出异常时，回滚事务）
* 6.释放资源
*/
@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("ysk");
customer.setCustIndustry("IT");
//保存
em.persist(customer); //保存操作
//5.提交事务
tx.commit();
//6.释放资源
em.close();
factory.close();
}
}