hibernate 和 jpa简介

最新推荐文章于 2024-05-31 19:26:12 发布
最新推荐文章于 2024-05-31 19:26:12 发布
阅读量6.1k 收藏 25
点赞数 6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshisunxinyuan/article/details/82765023
版权

hibernate 和 jpa简介

小引

长时间以来，人们解决持久层的方案，无论是jdbc、dbutils还是mybatis、jdbcTemplate，都无法跳出对SQL的高度关注，也就是说，大家始终要花费大量的时间去写简单的CRUD代码。因此，人们设想能不能通过某种方法，让我们不用再编写简单的CRUD语句而是直接建立某种对应关系实现表的操作，因此hibernate框架诞生了。

什么是ORM思想？

ORM（Object-Relational Mapping）
Object：java对象
Relational：关系型数据库
Mapping：映射（对应关系的映射）
ORM:通过操作实体类就能直接操作数据库，依据的是对应关系的建立

Hibernate概述

它是一个 开源的，轻量级的，基于ORM思想的企业级应用框架。通过实体类自动生成sql语句，实现程序员经过sql而操作数据库的可能。

JPA概述

JPA及java持久化API，是sun公司基于ORM思想提供的一套规范

hibernate 和 jpa的关系

jpa是一套接口和规范，hibernate是它其中一种的实现。

jpa的常用对象

Persistence
JPA的核心对象 主要负责创建 EntityManagerFactory

EntityManagerFactory
类似于SqlSessionFactory SqlSession IOC原理：工厂 + 反射 + 配置
此处使用工厂模式，一劳永逸 降低耦合

EntityManager
它是JPA中的持久化对象 封装所有的持久化方法，以及EntityTransaction

EntityTransaction
事务对象，目的是同化不同事物类型的差异，简便开发

JPA中的主键生成策略

IDENTITY
适用于数据库支持列的自增长情况 mysql db2(ibm)
SEQUENCE
适用于数据库支持序列的情况 Oracle db2
TABLE
用额外的一张表来维护你的主键
AUTO
默认就是Auto 默认使用Table

不完美：jpa提供的 主键生成策略 只限于 数值型

JPA的入门案例

配置文件(src下META-INF下persistence.xml 固定死的位置不能变)

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence  
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"  
    version="2.0">  
    <!-- 持久化单元块 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
          <!-- 数据库连接信息 
               	使用hibernate提供的 在hibernate的源码包下project/etc/hibernate.properties
           -->
           <properties>
              <!-- 必须配置 -->
              <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
              <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test"/>
              <property name="hibernate.connection.username" value="root"/>
              <property name="hibernate.connection.password" value="root"/>
              <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/><!-- 方言：数据库提供商对SQL的扩展 -->
              <!-- 可选配置 -->
              <property name="hibernate.show_sql" value="true"/>
              <property name="hibernate.format_sql" value="true"/>
              <!-- DDL语句生成策略
  					update的含义：当程序运行会自动检测实体类和数据库的表结构是否有差异，一旦有会立即更新表结构
  					使用场景：
  					    适合：开发阶段 
  					  不适合：线上阶段
				-->
              <property name="hibernate.hbm2ddl.auto" value="update"/>
              <!-- c3p0连接池信息 -->
              <property name="hibernate.connection.provider_class" value="org.hibernate.connection.C3P0ConnectionProvider"/>
           </properties>
    </persistence-unit>
    
</persistence>

实体类


package com.itheima.domain;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
* <p>Title: Customer</p>  
* <p>Description: 客户的实体类</p>  
* @author zhaocq 
* @date 2018年9月18日
 */
@Entity
@Table(name="cst_customer")
public class Customer implements Serializable {

	@Id
	@Column(name="cust_id")
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer custId;
	
	@Column(name="cust_name")
	private String  custName; 
	
	@Column(name="cust_source")
	private String  custSource;
	
	@Column(name="cust_industry")
	private String  custIndustry;
	
	@Column(name="cust_level")
	private String custLevel;
	
	@Column(name="cust_address")
	private String  custAddress;
	
	@Column(name="cust_phone")
	private String  custPhone;
	
	
	public Integer getCustId() {
		return custId;
	}
	public void setCustId(Integer 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 getCustIndustry() {
		return custIndustry;
	}
	public void setCustIndustry(String custIndustry) {
		this.custIndustry = custIndustry;
	}
	public String getCustLevel() {
		return custLevel;
	}
	public void setCustLevel(String custLevel) {
		this.custLevel = custLevel;
	}
	public String getCustAddress() {
		return custAddress;
	}
	public void setCustAddress(String custAddress) {
		this.custAddress = custAddress;
	}
	public String getCustPhone() {
		return custPhone;
	}
	public void setCustPhone(String custPhone) {
		this.custPhone = custPhone;
	}
	@Override
	public String toString() {
		return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource
				+ ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress
				+ ", custPhone=" + custPhone + "]";
	}			
}

测试Demo（DDL建表）

package com.itheima.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import org.junit.Test;

import domain.Customer;

public class JpaTest {
	
	@Test
	public void test() {
		//创建entityManagerFactory工厂
		EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
		//获得EntityManager对象
		EntityManager em = entityManagerFactory.createEntityManager();
		//获取事物对象
		EntityTransaction tx = em.getTransaction();
		//开启事物
		tx.begin();
		Customer customer = new Customer();
		customer.setCustName("hello jpa");
		//保存操作
		em.persist(customer);
		//提交事物
		tx.commit();
		//关闭资源
		em.close();
		entityManagerFactory.close();
	}
}

JPA的CRUD

抽取工具类

package utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class EntityManagerUtil {
	private static EntityManagerFactory entityManagerFactory;
	
	static {
		entityManagerFactory=Persistence.createEntityManagerFactory("myJpa");
	}
	
	public EntityManager createEntityManager() {
		return entityManagerFactory.createEntityManager();
	}
}

增删改查方法

package com.itheima.test;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

import org.junit.Test;

import domain.Customer;
import utils.EntityManagerUtil;

public class JpaCRUDTest {
	
	//增
	@Test
	public void addTest() {
		Customer customer = new Customer();
		customer.setCustName("hello jpa3");
		customer.setCustPhone("110");
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//增加persist方法
		em.persist(customer);
		tx.commit();
		em.close();
	}
	
	//查
	@Test
	public void findTest() {
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//查询find方法
		Customer c = em.find(Customer.class, 1);
		System.out.println(c);
		tx.commit();
		em.close();
	}
	
	//改
	@Test
	public void updateTest() {
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//先查询
		Customer c = em.find(Customer.class, 1);
		//在用merge修改
		c.setCustName("改名字了");
		em.merge(c);
		System.out.println(c);
		tx.commit();
		em.close();
	}
	
	//删
	@Test
	public void delTest() {
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//先查询
		Customer c = em.find(Customer.class, 1);
		//在用remove删除
		em.remove(c);
		tx.commit();
		em.close();
		}
	
	//查询全部
	@Test
	public void findAllTest() {
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//查询find方法
		Query query = em.createQuery("from Customer");// JPQL java persistence query language
		List<Customer> resultList = query.getResultList();
		for (Customer customer : resultList) {
			System.out.println(customer);
		}
		tx.commit();
		em.close();
	}
	
	//聚合函数
	@Test
	public void test() {
		EntityManager em = EntityManagerUtil.createEntityManager();
		EntityTransaction tx = em.getTransaction();
		tx.begin();
		//查询find方法
		Query query = em.createQuery("select count(custId) from Customer");// JPQL java persistence query language
		List<Customer> resultList = query.getResultList();
		System.out.println(resultList.get(0));
		tx.commit();
		em.close();
	}
}

JPA中的两种查询方式

Find和 getReference 的区别：
1. 加载时机不一样，find是立即加载，getReference是
延迟加载。
2. 返回的对象不一样，find返回的就是实体对象，
getReference返回的是代理对象。

Hibernate 的CRUD 练习

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   
    <session-factory>
        <!-- 必须配置 -->
	     <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	     <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
	     <property name="hibernate.connection.username">root</property>
	     <property name="hibernate.connection.password">admin</property>
	     <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 可选配置 -->
	     <property name="hibernate.show_sql">true</property>
	     <property name="hibernate.format_sql">true</property>
	     <property name="hibernate.hbm2ddl.auto">update</property>
	     <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!-- 实体类的位置 -->
        <mapping class="com.itheima.domain.Customer"/>
    </session-factory>
</hibernate-configuration>

抽取工具类

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
* <p>Title: HibernateUtil</p>  
* <p>Description: Hibernate的工具类</p>  
* @author zhaocq 
* @date 2018年9月18日
 */
public class HibernateUtil {

//	 private static EntityManagerFactory factory;
	 private static SessionFactory factory;
	 
	 static{
		 // 创建工厂
//		 factory = Persistence.createEntityManagerFactory("myJpa");
		 // 创建Configuration对象
		 Configuration configuration = new Configuration();
		 configuration.configure();
		 factory = configuration.buildSessionFactory();
	 }
	 
	 public static Session createSession(){
		 return factory.openSession();
	 }
}

CURD

package com.itheima.test;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import domain.Customer;
import utils.HibernateUtil;



/**
* <p>Title: JpaTest</p>  
* <p>Description:Hibernate的crud操作</p>  
* @author zhaocq 
* @date 2018年9月18日
 */
public class HibernateCRUDTest {
 
	/**
	 * <p>Title: test</p>  
	 * <p>Description: 保存</p>
	 */
	 @Test
	 public void test(){
		 Customer c = new Customer();
		 c.setCustName("hello Hibernate");
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 执行保存操作
		 session.save(c);
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
	 /**
	  * <p>Title: test1</p>  
	  * <p>Description: 根据ID查询</p>
	  */
	 @Test
	 public void test1(){
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 执行保存操作
		 Customer c = session.get(Customer.class, 1);
		 System.out.println(c);
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
	 
	 /**
	  * <p>Title: test2</p>  
	  * <p>Description:更新 </p>
	  */
	 @Test
	 public void test2(){
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 执行保存操作
		 Customer c = session.get(Customer.class, 1);
		 c.setCustName("javaee520");
		 session.update(c);
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
	 /**
	  * <p>Title: test3</p>  
	  * <p>Description: 删除</p>
	  */
	 @Test
	 public void test3(){
		 Customer c = new Customer();
		 c.setCustId(2);
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 执行保存操作
		 //Customer c = session.get(Customer.class, 1);
		 session.delete(c);
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
	 /**
	  * <p>Title: test4</p>  
	  * <p>Description: 查询全部</p>
	  */
	 @Test
	 public void test4(){
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 创建Query 
		 Query query = session.createQuery("from Customer");// HQL hibernate query language
		 List<Customer> list = query.list();
			for(Customer l:list){
				System.out.println(l);
			}
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
	 /**
	  * <p>Title: test5</p>  
	  * <p>Description: 聚合函数的使用</p>
	  */
	 @Test
	 public void test5(){
		 // 获取Session
		 Session session = HibernateUtil.createSession();
		 Transaction tx = session.beginTransaction();
		 // 创建Query 
		 Query query = session.createQuery("select count(custId) from Customer");// JPQL java persistence query language
		 Object uniqueResult = query.uniqueResult();
		 System.out.println(uniqueResult);	
		 // 提交事务
		 tx.commit();
		 // 关闭相关资源
		 session.close();
	 }
	 
}
小圆圈儿
关注
  • 6
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JPA和Hibernate到底是什么关系？？？
diaoyinyuan2801的博客
08-17 1325
（文章借用了其他几篇博客中的内容，因为是初学者，许多概念性的关系自己不能完全理解，就将大神的搬了过来，如有不当，可留言，本人自会妥善处理，谢谢） 在学习框架的过程中，发现学的东西很多，但是感觉他们之间的联系区别都不是很了解，知道JPA可以去实现持久化数据到数据库当中，Hibernate也有这样的功能，总以为他们之间是一种平级的关系，拥有同样的作用，是一种可以相互替代的关系，就像你吃...
基于Java的Hibernate和JPA持久层框架设计源码
最新发布
06-07
本项目为“基于Java的Hibernate和JPA持久层框架设计源码”，包含92个文件，其中65个Java源文件、21个XML配置文件、1个Gitignore文件、1个Spring Beans配置文件、1个SQL脚本文件、1个属性文件和1个JSP页面。...
Jpa使用详解（Hibernate）
Java后端技术栈
12-14 4927
Jpa使用详解 ORM思想 1.ORM概述 ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射 简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。 2.为什么要使用ORM 当实现一个应用程序时（不使用O/R Mapping）
Hibernate JPA 快速入门
qq_35254085的博客
04-28 2103
1、Hibernate JPA简介 1.1、认识 hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将 POJO与数据库表建立映射关系，是一个全自动的 orm 框架，hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。 1.2、认识 JPA JPA的全称：Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，
【八股】Hibernate和JPA：理解它们的关系
Mia惠枫的博客
05-31 450
JPA是一个标准规范，定义了一套接口和注解，用于对象-关系映射和持久化操作；Hibernate是JPA的一个具体实现，同时也是一个功能丰富的ORM框架。通过JPA的API使用Hibernate，开发者可以获得标准化的接口和强大的持久化功能，从而在开发中取得更高的效率和灵活性。希望这篇博客能够帮助你更好地理解Hibernate和JPA之间的关系，以及它们在Java开发中的重要作用。
JPA-Hibernate
Wqr_18390921824的博客
12-01 780
一. JPA与hibernate的关系 JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。 JPA和Hibernate的关系就像JDBC和数据库JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要..
一篇文章带你搞懂 JPA 和 hibernate
南淮北安的博客
07-10 3144
文章目录一、认识 hibernate二、认识 JPA三、JPA 与 hibernate 的关系 一、认识 hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将 POJO与数据库表建立映射关系，是一个全自动的 orm 框架，hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。 二、认识 JPA JPA的全称是Java Persistence API， 即Java 持久化
hibernate-jpa-2.1-api-1.0.2.Final-API文档-中文版.zip
06-25
赠送jar包：hibernate-jpa-2.1-api-1.0.2.Final.jar； 赠送原API文档：hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar； 赠送源代码：hibernate-jpa-2.1-api-1.0.2.Final-sources.jar； 赠送Maven依赖信息文件：...
hibernate-jpa-2.1-api-1.0.2.Final-API文档-中英对照版.zip
06-12
赠送jar包：hibernate-jpa-2.1-api-1.0.2.Final.jar； 赠送原API文档：hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar； 赠送源代码：hibernate-jpa-2.1-api-1.0.2.Final-sources.jar； 赠送Maven依赖信息文件：...
JPA注解 和hibernate 建表
07-07
JPA和Hibernate的关系可以概括为：JPA是一个抽象层次，而Hibernate是一个具体的实现。 七、建表过程 建表过程可以分为两种方式： * 先建表：根据数据库表编写配置文件的实体Bean * 先编写文件和实体Bean，然后...
hibernate-jpa.jar
07-14
全称为Hibernate Java Persistence API，是Hibernate组织提供的一种基于Java平台的企业级对象关系映射（ORM）解决方案，它实现了Java Persistence API（JPA），使得Java开发者能够方便地在关系数据库和面向对象的...
Hibernate与JPA持久化：深入解析与实践
勤劳的小琪
04-14 563
Hibernate是一个开源的ORM框架，它提供了Java对象与关系数据库之间的映射。Hibernate不仅负责将Java对象保存到数据库中，还负责从数据库中读取数据并封装为Java对象。它隐藏了底层JDBC的复杂性，使得开发者能够专注于业务逻辑的实现。JPA是Java EE规范中的一部分，它定义了一套标准的API用于对象关系映射。JPA的目标是简化持久化操作，提供统一的编程接口，使得开发者能够在不同的ORM框架之间轻松切换。Hibernate和JPA在Java企业级应用中扮演着至关重要的角色。
JPA与hibernate
weixin_42494845的博客
08-23 456
hibernate概述 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 JPA概述 JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。 JPA通过JDK 5.0注解描述对象－关系表
ORM框架之Spring Data JPA（一）Hibernate实现JPA规范
小蜜蜂1010的博客
10-05 1512
一、ORM简述 ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射。简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的...
【SpringBoot整合JPA框架（hibernate实现）详解】（附详细代码）
qq_45759093的博客
02-20 2809
Java Persistence API（JPA）是Java EE和Java SE平台的一部分，提供了一种简单的对象关系映射（ORM）机制，用于将Java对象持久化到关系型数据库中。JPA通过注解或XML配置文件实现实体类与数据库表之间的映射，简化了数据库操作的过程。
Hibernate、JPA和Spring Data JPA之间对比
爱琴孩的博客
09-02 306
Hibernate是具备对象关系映射能力的强大的ORM框架，虽然JPA是Java中的ORM规范，但是只定义了一组用于持久化的标准化API，而提供了对JPA的简化抽象，提供了额外的能力和抽象存储。这就是HibernateJPA和技术之间的区别。了解HibernateJPA和之间的差异对于面试准备和构建具有高效数据库交互的健壮Java应用程序至关重要。Hibernate作为一个强大的ORM框架，实现了JPA规范并提供了额外的特性。通过在JPA和Hibernate之上提供抽象存储和生成动态查询来简化数据库访问。
JPA与Hibernate区别及之间的关系
旷野历程
11-04 6993
分享知识 传递快乐 JPA与Hibernate 的区别 JPA和Hibernate之间的最大的区别是： JPA是一个规范，不是框架 Hibernate是JPA的实现 也可以简单的理解为JPA是标准接口，Hibernate是实现。 那么Hibernate是如何实现与JPA的这种关系的呢？ Hibernate主要是通过三个组件来实现的，及hibernate-annotation、hi...
JPA-Hibernate快速入门图文教程
m0_63270506的博客
05-13 674
目录 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...
JPA的概念与Hibernate
qq_36501760的博客
05-20 337
JPA的概念与Hibernate 目录 JPA的概念与Hibernate一. JPA的概念二. Hibernate框架简介三. 基本操作1. 导入包2. 编写配置文件3. 编写代码4. Hibernate中对象的三种状态5. 一级缓存6. 二级缓存7. Hibernate中延迟加载8. Hibernate的关联关系9. Hibernate查询 一. JPA的概念 Java persistance ...
hibernate+jpa
08-25
嗨！关于 Hibernate JPA，我可以给你一些基本的介绍。Hibernate是一个开源的对象关系映射(ORM)框架，用于将Java对象映射到关系数据库中的数据表。JPA（Java Persistence API）是Java EE的持久化标准，它定义了一组API和规范，用于管理对象的持久化和数据库访问。 通过使用Hibernate JPA，你可以使用简单的注解和配置来实现对象与数据库之间的映射关系。它提供了一种方便的方式来执行CRUD操作（创建、读取、更新和删除）以及其他高级查询。 要使用Hibernate JPA，你需要在项目中添加Hibernate和JPA的依赖，配置持久化单元（Persistence Unit），并创建实体类来映射到数据库表格。然后，你可以使用EntityManager来执行各种数据库操作。 除了基本的CRUD操作，Hibernate JPA还提供了许多高级特性，例如延迟加载、缓存管理、事务管理等。它还支持JPQL（Java Persistence Query Language），这是一种类似于SQL的查询语言，用于执行复杂的数据库查询。 总的来说，Hibernate JPA是一个强大而灵活的框架，可以简化Java应用程序与关系数据库之间的交互。它使得持久化和数据库访问变得更加简单和高效。如果你对具体的使用细节或者其他相关问题有兴趣，我可以给你提供更多的帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值