目录
1、JPA 和JDBC 的相同处和不同处
2、什么是JPA
3、Hibernate与JPA
4、mybatis和hibernate
5、Hibernate的CRUD *** 作案例
主结构：编辑
springdata→pom.xml ：
01-jpa-hibernate→pom.xml ：
pojo→Customer实体类：
hibernate.cfg.xml 文件：
HibernateTest测试
6、JPA的CRUD *** 作案例
主结构：编辑
springdata→pom.xml ：
01-jpa-hibernate→pom.xml ：
pojo→Customer实体类：
添加META-INF\persistence.xml
JpaTest测试
1、JPA 和JDBC 的相同处和不同处 相同处： 1.都跟数据∙库 *** 作有关，JPA 是JDBC 的升华，升级版。 2.JDBC和JPA都是一组规范接口 3.都是由SUN官方推出的 不同处： 1.JDBC是由各个关系型数据库实现的， JPA 是由 ORM框架 实现 2.JDBC 使用SQL语句和数据库通信。 JPA用面向对象方式， 通过ORM框架来生成SQL，进行 *** 作。
3.JPA在JDBC之上的， JPA也要依赖JDBC才能 *** 作数据库。
2、什么是JPA JPA全称Java Persistence API ， 是Sun官方提出的 一种ORM规范。 O:Object R: Relational M:mapping 作用 1.简化持久化 *** 作的开发工作：让 开发者从繁琐的 JDBC 和 SQL 代码中解脱出来，直接面向对象持久化 *** 作。 2.Sun希望持久化技术能够统一，实现天下归一：如果你是基于JPA进行持久化你可以随意切换数据库。 该规范为我们提供了： 1） ORM映射元数据 ：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对 象持久化到数据库表中； 如： @Entity 、 @Table 、 @Id 与 @Column 等注解。 2） JPA 的API ：用来 *** 作实体对象，执行CRUD *** 作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和 SQL代码中解脱出来。 如： entityManager.merge(T t) ； 3） JPQL查询语言 ：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。 如： from Student s where s.name = ? So: JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的。
3、Hibernate与JPA JPA是一套ORM规范，Hibernate实现了JPA规范！
4、mybatis和hibernate mybatis：小巧、方便？、高效、简单、直接、半自动 半自动的ORM框架， 小巧： mybatis就是jdbc封装 在国内更流行。 场景： 在业务比较复杂系统进行使用， hibernate：强大、方便、高效、（简单）复杂、绕弯子、全自动 全自动的ORM框架， 强大：根据ORM映射生成不同SQL 在国外更流。 场景： 在业务相对简单的系统进行使用，随着微服务的流行。
5、Hibernate的CRUD *** 作案例 主结构： springdata→pom.xml ：
4.0.0
com.tuling.springdata
springdata
pom
1.0-SNAPSHOT
01-jpa-hibernate
02-springdata-jpa
03-springdata-jpa
04-springdata-jpa
8
8
org.springframework.data
spring-data-bom
2021.1.0
import
pom
springdata
com.tuling.springdata
1.0-SNAPSHOT
4.0.0
01-jpa-hibernate
8
8
junit
junit
4.13
test
org.hibernate
hibernate-entitymanager
5.4.32.Final
mysql
mysql-connector-java
5.1.22
org.apache.openjpa
openjpa-all
3.2.0
package com.tuling.pojo;
import javax.persistence.*;
@Entity // 作为hibernate 实体类
@Table(name = "tb_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 = "id")//配置属性和字段的映射关系 name：数据库表中字段的名称
private Long custId; //客户的主键
@Column(name = "cust_name")
private String custName;//客户名称
@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 getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName='" + custName + '\'' +
", custAddress='" + custAddress + '\'' +
"}\n";
}
}
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8
root
123456
true
true
update
org.hibernate.dialect.MySQL57InnoDBDialect
package com.tuling.test;
import com.tuling.pojo.Customer;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
public class HibernateTest {
// Session工厂 Session:数据库会话 代码和数据库的一个桥梁
private SessionFactory sf;
@Before
public void init() {
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate.cfg.xml").build();
//2. 根据服务注册类创建一个元数据资源集，同时构建元数据并生成应用一般唯一的的session工厂
sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();
}
//增
@Test
public void testC(){
// session进行持久化 *** 作
//使用try意思就是他会帮我们自动关闭
try(Session session = sf.openSession()){
//开启事务
Transaction tx = session.beginTransaction();
Customer customer = new Customer();
customer.setCustName("徐庶");
session.save(customer);
// session.remove(); //删除
// session.update(); //更新
// session.save(); //插入
// session.find(); //查找
tx.commit();
}
}
//查
@Test
public void testR(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
Customer customer = session.find(Customer.class, 1L);
System.out.println("=====================");
System.out.println(customer);
tx.commit();
}
}
//查询，懒加载方式
@Test
public void testR_lazy(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
Customer customer = session.load(Customer.class, 1L);
System.out.println("=====================");
System.out.println(customer);
tx.commit();
}
}
//更新
@Test
public void testU(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
Customer customer = new Customer();
//customer.setCustId(1L);
customer.setCustName("徐庶");
// 插入session.save()
// 更新session.update();
session.saveOrUpdate(customer);//如果不存在他会为你创建，如果存在他就会为你更新
tx.commit();
}
}
//删除
@Test
public void testD(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
Customer customer = new Customer();
customer.setCustId(2L);
session.remove(customer);
tx.commit();
}
}
//HQL查询全部
@Test
public void testR_HQL(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
String hql=" FROM Customer";
List resultList = session.createQuery(hql, Customer.class)
// .setParameter("id",1L)
.getResultList();//获取查询集合
System.out.println(resultList);
tx.commit();
}
}
//HQL查询单个
@Test
public void testR_HQL2(){
// session进行持久化 *** 作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
String hql=" FROM Customer where custId=:id";
List resultList = session.createQuery(hql, Customer.class)
.setParameter("id",1L)//查询id为1l的人的信息，与上面HQL语句：where custId=:id 对应
.getResultList();//获取查询集合
System.out.println(resultList);
tx.commit();
}
}
}
6、JPA的CRUD *** 作案例 （如果单独使用hibernate的API来进行持久化 *** 作，则不能随意切换其他ORM框架 ） 主结构： springdata→pom.xml ：
4.0.0
com.tuling.springdata
springdata
pom
1.0-SNAPSHOT
01-jpa-hibernate
02-springdata-jpa
03-springdata-jpa
04-springdata-jpa
8
8
org.springframework.data
spring-data-bom
2021.1.0
import
pom
springdata
com.tuling.springdata
1.0-SNAPSHOT
4.0.0
01-jpa-hibernate
8
8
junit
junit
4.13
test
org.hibernate
hibernate-entitymanager
5.4.32.Final
mysql
mysql-connector-java
5.1.22
org.apache.openjpa
openjpa-all
3.2.0
package com.tuling.pojo;
import javax.persistence.*;
@Entity // 作为hibernate 实体类
@Table(name = "tb_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 = "id")//配置属性和字段的映射关系 name：数据库表中字段的名称
private Long custId; //客户的主键
@Column(name = "cust_name")
private String custName;//客户名称
@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 getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName='" + custName + '\'' +
", custAddress='" + custAddress + '\'' +
"}\n";
}
}
org.hibernate.jpa.HibernatePersistenceProvider
com.tuling.pojo.Customer
org.apache.openjpa.persistence.PersistenceProviderImpl
com.tuling.pojo.Customer
package com.tuling.test;
import com.tuling.pojo.Customer;
import org.junit.Before;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
public class JpaTest {
EntityManagerFactory factory;
@Before
public void before(){
factory= Persistence.createEntityManagerFactory("hibernateJPA");//括号里面是持久化单元的名称
}
//增
@Test
public void testC(){
EntityManager em = factory.createEntityManager();//这里生成的 em ，就相当于Hibernate里面生成的 session
EntityTransaction tx = em.getTransaction();
tx.begin();//开启事务
Customer customer = new Customer();
customer.setCustName("张三");
em.persist(customer);//插入
tx.commit();//提交
}
// 立即查询
@Test
public void testR(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = em.find(Customer.class, 1L);
System.out.println("========================");
System.out.println(customer);
tx.commit();
}
// 延迟查询
@Test
public void testR_lazy(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = em.getReference(Customer.class, 1L);
System.out.println("========================");
System.out.println(customer);
tx.commit();
}
//修改
@Test
public void testU(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = new Customer();
customer.setCustId(3L);
customer.setCustName("王五");
/*
*
// 如果指定了主键：
更新： 1.先查询 看是否有变化
如果有变化 更新 如果没有变化就不更新
*
* 如果没有指定了主键：
* 插入
* */
em.merge(customer);
tx.commit();
}
//JPQL更新语句
@Test
public void testU_JPQL(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String jpql="UPDATE Customer set custName=:name where custId=:id";
em.createQuery(jpql)
.setParameter("name","李四")
.setParameter("id",3L)
.executeUpdate();
tx.commit();
}
//使用SQL更新语句
@Test
public void testU_SQL(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String sql="UPDATE tb_customer set cust_name=:name where id=:id";
em.createNativeQuery(sql)
.setParameter("name","王五")
.setParameter("id",3L)
.executeUpdate();
tx.commit();
}
//删除
@Test
public void testD(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = em.find(Customer.class,3L);//先查持久化状态的，然后再删
// jpa的对象4种状态
// 临时状态：刚创建出来，∙没有与entityManager发生关系，没有被持久化，不处于entityManager中的对象
// 持久状态：∙与entityManager发生关系，已经被持久化，您可以把持久化状态当做实实在在的数据库记录。
// 删除状态：执行remove方法，事物提交之前
// 游离状态：游离状态就是提交到数据库后，事务commit后实体的状态，因为事务已经提交了，此时实体的属 性任你如何改变，也不会同步到数据库，
// 因为游离是没人管的孩子，不在持久化上下文中。
em.remove(customer);
tx.commit();
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）