hibernate,jpa與spring?data?jpa之間有什么關系

小編給大家分享一下hibernate,jpa與spring data jpa之間有什么關系，希望大家閱讀完這篇文章之后都有所收獲，下面讓我們一起去探討吧！

文字說明

Hibernate

Hibernate是一個開放源代碼的對象關系映射框架，它對JDBC進行了非常輕量級的對象封裝，它將POJO與數據庫表建立映射關系，是一個全自動的orm框架，hibernate可以自動生成SQL語句，自動執行，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數據庫。

JPA

JPA全稱是Java Persistence API，即java持久化API，是sun公司推出的一套基于ORM的規范，內部由一系列的接口和抽象類構成。

JPA與Hibetnate的關系

JPA和Hibernate的關系就像JDBC和JDBC驅動的關系，JPA是規范，Hibernate除了作為ORM框架之外，它也是一種JPA實現。JPA怎么取代Hibernate呢？JDBC規范可以驅動底層數據庫嗎？答案是否定的，也就是說，如果使用JPA規范進行數據庫操作，底層需要hibernate作為其實現類完成數據持久化工作。

Spring Data jpa

Spring Data JPA 讓我們解脫了DAO層的操作，基本上所有CRUD都可以依賴于它來實現,在實際的工作工程中，推薦使用Spring Data JPA + ORM（如：hibernate）完成操作，這樣在切換不同的ORM框架時提供了極大的方便，同時也使數據庫層操作更加簡單，方便解耦

Hibernate、JPA與Spring Data JPA之間的關系

JPA是一套規范，內部是有接口和抽象類組成的。hibernate是一套成熟的ORM框架，而且Hibernate實現了JPA規范，所以也可以稱hibernate為JPA的一種實現方式，我們使用JPA的API編程，意味著站在更高的角度上看待問題（面向接口編程）Spring Data JPA是Spring提供的一套對JPA操作更加高級的封裝，是在JPA規范下的專門用來進行數據持久化的解決方案。以上就是對hibernate、JPA與Spring Data JPA三者之間的關系說明。

總結：

JPA是一種規范，Hibernate實現了JPA規范，即Hibernate為JPA的一種實現；而Spring Data JPA是對JPA進行更高級的封裝，讓其dao編碼變得更簡單。

CRUD操作

hibernate的crud操作

首先創建數據庫表

創建hibernate核心配置文件hibernate.cfg.xml

<?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.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 配置和當前線程綁定的session進行開啟配置 -->
		<property name="hibernate.current_session_context_class">thread</property>
		<!-- 引入映射文件 -->
		<mapping resource="cn/itcast/domain/Customer.hbm.xml" />
	</session-factory>
</hibernate-configuratio

創建實體類Customer（和數據庫表映射的類）

package cn.itcast.domain;
public class Customer 
{
	 private Long cust_id;// '客戶編號(主鍵)',
	 private String cust_name;// '客戶名稱(公司名稱)',
	 private String cust_source;// '客戶信息來源',
	 private String cust_industry;//'客戶所屬行業',
	 private String cust_level;// '客戶級別',
	 private String cust_address;// '客戶聯系地址',
	 private String cust_phone;// '客戶聯系電話',
	public Long getCust_id() {
		return cust_id;
	}
	public void setCust_id(Long cust_id) {
		this.cust_id = cust_id;
	}
	public String getCust_name() {
		return cust_name;
	}
	public void setCust_name(String cust_name) {
		this.cust_name = cust_name;
	}
	public String getCust_source() {
		return cust_source;
	}
	public void setCust_source(String cust_source) {
		this.cust_source = cust_source;
	}
	public String getCust_industry() {
		return cust_industry;
	}
	public void setCust_industry(String cust_industry) {
		this.cust_industry = cust_industry;
	}
	public String getCust_level() {
		return cust_level;
	}
	public void setCust_level(String cust_level) {
		this.cust_level = cust_level;
	}
	public String getCust_address() {
		return cust_address;
	}
	public void setCust_address(String cust_address) {
		this.cust_address = cust_address;
	}
	public String getCust_phone() {
		return cust_phone;
	}
	public void setCust_phone(String cust_phone) {
		this.cust_phone = cust_phone;
	}	 
}

創建Hibernate映射文件Customer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 做類(Customer)和表(cst_customer)的映射關系 -->
<hibernate-mapping>
		<!-- 
			class標簽: 作用類和表的映射的
		 		name:類的全限定名(cn.itcast.domain.Customer)
		 		table:表的全名(cst_customer)
		 -->
		<class name="cn.itcast.domain.Customer" table="cst_customer">
			<!-- 
				id標簽:做類中的某個屬性 和 表的主鍵映射關系
				 name:類的某個屬性名
				 column:表的主鍵字段名
			 -->
			<id name="cust_id" column="cust_id">
				<!-- 做主鍵的增長方式的   
					  native: AUTO_INCREMENT 讓主鍵自動增長 -->
				<generator class="native"></generator>
			</id>
			
			<!-- 
				property標簽:做其它屬性和其它字段的映射關系 
				   name屬性:類的其它屬性名
				   column屬性:表的其它字段名
				   ps:如果屬性名和字段名一致 column可以省略不寫
			-->
			<property name="cust_name" column="cust_name" length="20" not-null="true" unique="true"></property>
			<property name="cust_source" column="cust_source"></property>
			<property name="cust_industry" column="cust_industry"></property>
			<property name="cust_level" column="cust_level"></property>
			<property name="cust_address" column="cust_address"></property>
			<property name="cust_phone" column="cust_phone"></property>
		</class>
</hibernate-mapping>

以上我們就完成了dao層的編碼工作。現在我們來測試：

創建工具類HibernateUtils

package cn.itcast.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils 
{
		static Configuration configuration =null;
		static SessionFactory sessionFactory = null;
		static
		{
			// 加載一次配置文件
			configuration = new Configuration();
			configuration.configure();
			
			// 獲取一個sessionFactory
			sessionFactory=configuration.buildSessionFactory();
			
		}
		
		// 從連接池獲取的
		public static Session openSession()
		{
			return sessionFactory.openSession();
		}
		
		// 從當前線程中獲取綁定的session 
		// 好處: 在多層之間調用方法獲取的都是同一個session
		public static Session getCurrentSession()
		{
			/*特點: 1 默認是關閉的 需要配置開啟
				   2 會自動給你關閉連接*/
			Session session = sessionFactory.getCurrentSession();
			return session;
		}
}

通過以上工具類，我們就可以輕松地獲取管理hibernate的seesion對象，session對象具備crud的一系列方法。

save()：保存操作

@Test
	public void test2()
	{
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setCust_name("bbbbb");
		session.save(customer);		
		tx.commit();
		session.close();
	}

get()：查詢

// oid查詢
	@Test
	public void test1() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		Customer customser = session.get(Customer.class, "abcdefg");
		System.out.println(customser);
		tx.commit();
		session.close();
		// 只有增刪改 一級oid查詢 才會自動生成sql語句
	}

通過HQL方式查詢：

@Test
	public void test3() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		// 條件查 類似sql語句的表達式 from 持久化類 where 屬性=?
		Query qr = session.createQuery("from Customer where cust_name like ?");
		qr.setParameter(0, "h%");
		List<Customer> list = qr.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		tx.commit();
		session.close();
	}

通過sql方式查詢：

@Test
	public void test5() {
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		// 單列查 返回是Object
		Query qr = session.createQuery("select cust_id from Customer");
		List<Object> list = qr.list();
		for (Object object : list) {
			System.out.println(object);
		}
		tx.commit();
		session.close();
	}

JPA的crud操作

該操作我們用maven的方式來構建依賴

首先我們需要引入依賴：

<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.hibernate.version>5.0.7.Final</project.hibernate.version>
	</properties>
	<dependencies>
		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!-- hibernate對jpa的支持包 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>
		<!-- c3p0 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-c3p0</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>
		<!-- log日志 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
		<!-- Mysql and MariaDB -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.6</version>
		</dependency>
	</dependencies>

在resources目錄下創建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">
	<!--配置持久化單元 
		name：持久化單元名稱 
		transaction-type：事務類型
		 	RESOURCE_LOCAL：本地事務管理 
		 	JTA：分布式事務管理 -->
	<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
		<!--配置JPA規范的服務提供商 -->
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<properties>
			<!-- 數據庫驅動 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<!-- 數據庫地址 -->
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?characterEncoding=utf-8" />
			<!-- 數據庫用戶名 -->
			<property name="javax.persistence.jdbc.user" value="root" />
			<!-- 數據庫密碼 -->
			<property name="javax.persistence.jdbc.password" value="root" />
			<!--jpa提供者的可選配置：我們的JPA規范的提供者為hibernate，所以jpa的核心配置中兼容hibernate的 -->
			<!--配置jpa實現方(hibernate)的配置信息
                顯示sql           ：   false|true
                自動創建數據庫表    ：  hibernate.hbm2ddl.auto
                        create      : 程序運行時創建數據庫表（如果有表，先刪除表再創建）
                        update      ：程序運行時創建表（如果有表，不會創建表）
                        none        ：不會創建表
            -->
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="true" />
			<property name="hibernate.hbm2ddl.auto" value="create" />
		</properties>
	</persistence-unit>
</persistence>

創建和數據庫表映射的實體類

package com.ithubei.entity;
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;
/**
 * @Entity
        	作用：指定當前類是實體類。
        @Table
        	作用：指定實體類和表之間的對應關系。
        	屬性：
        		name：指定數據庫表的名稱
        @Id
        	作用：指定當前字段是主鍵。
        @GeneratedValue
        	作用：指定主鍵的生成方式。。
        	屬性：
        		strategy ：指定主鍵生成策略。
        @Column
        	作用：指定實體類屬性和數據庫表之間的對應關系
        	屬性：
        		name：指定數據庫表的列名稱。
        		unique：是否唯一  
        		nullable：是否可以為空  
        		inserttable：是否可以插入  
        		updateable：是否可以更新  
        		columnDefinition: 定義建表時創建此列的DDL  
        		secondaryTable: 從表名。如果此列不建在主表上（默認建在主表），該屬性定義該列所在從表的名字搭建開發環境[重點]
 * @author DELL
 *
 */
@Entity  //聲明該類是和數據庫表映射的實體類
@Table(name="cst_customer")  //建立實體類與表的映射關系
public class Customer implements Serializable{
	@Id  //聲明當前私有屬性為主鍵
	@GeneratedValue(strategy=GenerationType.IDENTITY)  //配置主鍵的生成策略，為自增主鍵
	@Column(name = "cust_id")
	private Long custId;
	
	@Column(name="cust_name")  //指定和表中cust_name字段的映射關系
	private String custName;
	
	@Column(name="cust_source")  //指定和表中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 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 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;
	}	
}

創建工具類JpaUtils

package com.ithubei.utils;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
/**
 * 解決實體管理器工廠的浪費資源和耗時問題
 *      通過靜態代碼塊的形式，當程序第一次訪問此工具類時，創建一個公共的實體管理器工廠對象
 *
 * 第一次訪問getEntityManager方法：經過靜態代碼塊創建一個factory對象，再調用方法創建一個EntityManager對象
 * 第二次方法getEntityManager方法：直接通過一個已經創建好的factory對象，創建EntityManager對象
 */
public class JpaUtils {
	private static EntityManagerFactory entityManagerFactory;
	static {
		 //1.加載配置文件，創建entityManagerFactory
		entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
	}
	
	public static EntityManager getEntityManager() {
		return entityManagerFactory.createEntityManager();
	}
}

通過以上工具類，我們就可以得到EntityManager實體管理類來進行crud等操作。

在 JPA 規范中, EntityManager是完成持久化操作的核心對象。實體類作為普通 java對象，只有在調用 EntityManager將其持久化后才會變成持久化對象。EntityManager對象在一組實體類與底層數據源之間進行 O/R 映射的管理。它可以用來管理和更新 Entity Bean, 根椐主鍵查找 Entity Bean, 還可以通過JPQL語句查詢實體。

我們可以通過調用EntityManager的方法完成獲取事務，以及持久化數據庫的操作。

方法說明：

• getTransaction：獲取事務對象

• persist：保存操作

• merge：更新操作

• remove：刪除操作

• find（立即加載）/getReference（延遲加載）：根據id查詢

現在我們就來通過EntityManager對象來進行crud操作。

測試：

package com.ithubei.test;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import org.junit.Test;
import com.ithubei.entity.Customer;
import com.ithubei.utils.JpaUtils;
public class JpaTest {
	/**
	 * 保存操作
	 */
	@Test
	public void testSave() {
		//通過工具類來獲取EntityManager對象
		EntityManager em = JpaUtils.getEntityManager();
		//獲取事務對象
		EntityTransaction tx = em.getTransaction();
		tx.begin();  //開啟事務
		//完成增刪改查操作，保存一個用戶到數據庫中
		Customer customer = new Customer();
		customer.setCustName("授課");
		customer.setCustIndustry("教育");
		//保存操作
		em.persist(customer);
		tx.commit();  //提交事務
		em.close();  //釋放資源
	}
	
	/**
	 * 保存一個實體
	 */
	@Test
	public void testAdd() {
		// 定義對象
		Customer c = new Customer();
		c.setCustName("傳智學院");
		c.setCustLevel("VIP客戶");
		c.setCustSource("網絡");
		c.setCustIndustry("IT教育");
		c.setCustAddress("昌平區北七家鎮");
		c.setCustPhone("010-84389340");
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 獲取實體管理對象
			em = JpaUtils.getEntityManager();
			// 獲取事務對象
			tx = em.getTransaction();
			// 開啟事務
			tx.begin();
			// 執行操作
			em.persist(c);
			// 提交事務
			tx.commit();
		} catch (Exception e) {
			// 回滾事務
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 釋放資源
			em.close();
		}
	}
	/**
	 * 修改操作
	 */
	@Test
    public void testMerge(){  
        //定義對象
        EntityManager em=null;  
        EntityTransaction tx=null;  
        try{  
          	//獲取實體管理對象
          	em=JpaUtils.getEntityManager();
          	//獲取事務對象
          	tx=em.getTransaction();
          	//開啟事務
          	tx.begin();
          	//執行操作
          	Customer c1 = em.find(Customer.class, 6L);
          	c1.setCustName("江蘇傳智學院");
         	em.clear();//把c1對象從緩存中清除出去
          	em.merge(c1);
          	//提交事務
          	tx.commit(); 
        }catch(Exception e){
          	//回滾事務
          	tx.rollback();
          	e.printStackTrace();  
        }finally{  
        	//釋放資源
        	em.close();  
        }    
    }
	
	/**
	 * 刪除操作
	 */
	@Test
	public void testRemove() {
		// 定義對象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 獲取實體管理對象
			em = JpaUtils.getEntityManager();
			// 獲取事務對象
			tx = em.getTransaction();
			// 開啟事務
			tx.begin();
			// 執行操作
			Customer c1 = em.find(Customer.class, 6L);
			em.remove(c1);
			// 提交事務
			tx.commit();
		} catch (Exception e) {
			// 回滾事務
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 釋放資源
			em.close();
		}
	}
	
	/**
	 * 查詢操作find()
	 */
	@Test
	public void testGetOne() {
		// 定義對象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 獲取實體管理對象
			em = JpaUtils.getEntityManager();
			// 獲取事務對象
			tx = em.getTransaction();
			// 開啟事務
			tx.begin();
			// 執行操作
			Customer c1 = em.find(Customer.class, 96);
			// 提交事務
			tx.commit();
			System.out.println(c1); // 輸出查詢對象
		} catch (Exception e) {
			// 回滾事務
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 釋放資源
			em.close();
		}
	}
}

雖然我們已經使用EntityManager對象完成了JPA的新增改查操作，但是我們這里還要介紹另外一種查詢方式，那就是JPQL（java持久化查詢語言），JPQL與hibernate的HQL方式類似。

package com.ithubei.test;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import org.junit.Test;
import com.ithubei.utils.JpaUtils;
/**
 * 使用JPQL（java持久化查詢語言）來查詢數據
 * @author DELL
 *
 */
public class JpqlTest {
	/**
	 * 查詢全部的客戶
	 */
	@Test
	public void findAll() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//獲取是管理對象
			em = JpaUtils.getEntityManager();
			//獲取事務對象
			tx = em.getTransaction();
			//開啟事務
			tx.begin();
		
			String jpql = "from Customer";  
			//創建query對象
			Query query = em.createQuery(jpql);
			//使用query對象查詢客戶信息
			List list = query.getResultList();  //查詢所有的客戶
			for (Object object : list) {
				System.out.println(object);
			}
			
			//提交事務
			tx.commit();
		}catch (Exception e) {
			// TODO: handle exception
			//發生異常進行回滾
			tx.rollback();
			e.printStackTrace();
		}finally {
			//釋放資源
			em.close();
		}
	}
		//分頁查詢客戶
		@Test
		public void findPaged () {
			EntityManager em = null;
			EntityTransaction tx = null;
			try {
				//獲取實體管理對象
				em = JpaUtils.getEntityManager();
				//獲取事務對象
				tx = em.getTransaction();
				tx.begin();
				//創建query對象
				String jpql = "from Customer";
				Query query = em.createQuery(jpql);
				//起始索引
				query.setFirstResult(0);
				//每頁顯示條數
				query.setMaxResults(2);
				//查詢并得到返回結果
				List list = query.getResultList(); //得到集合返回類型
				for (Object object : list) {
					System.out.println(object);
				}
				tx.commit();
			} catch (Exception e) {
				// 回滾事務
				tx.rollback();
				e.printStackTrace();
			} finally {
				// 釋放資源
				em.close();
			}
		}
		
		//條件查詢
		@Test
		public void findCondition () {
			EntityManager em = null;
			EntityTransaction tx = null;
			try {
				//獲取實體管理對象
				em = JpaUtils.getEntityManager();
				//獲取事務對象
				tx = em.getTransaction();
				tx.begin();
				//創建query對象
				String jpql = "from Customer where custName like ? ";
				Query query = em.createQuery(jpql);
				//對占位符賦值，從1開始
				query.setParameter(1, "傳智%");
				//查詢并得到返回結果
				Object object = query.getSingleResult(); //得到唯一的結果集對象
				System.out.println(object);
				tx.commit();
			} catch (Exception e) {
				// 回滾事務
				tx.rollback();
				e.printStackTrace();
			} finally {
				// 釋放資源
				em.close();
			}
		}
		//根據客戶id倒序查詢所有客戶
		//查詢所有客戶
		@Test
		public void testOrder() {
			EntityManager em = null;
			EntityTransaction tx = null;
			try {
				//獲取實體管理對象
				em = JpaUtils.getEntityManager();
				//獲取事務對象
				tx = em.getTransaction();
				tx.begin();
				// 創建query對象
				String jpql = "from Customer order by custId desc";
				Query query = em.createQuery(jpql);
				// 查詢并得到返回結果
				List list = query.getResultList(); // 得到集合返回類型
				for (Object object : list) {
					System.out.println(object);
				}
				tx.commit();
			} catch (Exception e) {
				// 回滾事務
				tx.rollback();
				e.printStackTrace();
			} finally {
				// 釋放資源
				em.close();
			}
		}
		//統計查詢
		@Test
		public void findCount() {
			EntityManager em = null;
			EntityTransaction tx = null;
			try {
				//獲取實體管理對象
				em = JpaUtils.getEntityManager();
				//獲取事務對象
				tx = em.getTransaction();
				tx.begin();
				// 查詢全部客戶
				// 1.創建query對象
				String jpql = "select count(custId) from Customer";
				Query query = em.createQuery(jpql);
				// 2.查詢并得到返回結果
				Object count = query.getSingleResult(); // 得到集合返回類型
				System.out.println(count);  //客戶人數
				tx.commit();
			} catch (Exception e) {
				// 回滾事務
				tx.rollback();
				e.printStackTrace();
			} finally {
				// 釋放資源
				em.close();
			}
		}
}	

通過以上等操作，我們就完成了JPA的crud操作。

接下來我們就開始使用spring data jpa來完成crud操作，讓我們體會一下什么叫優勢。

spring data jpa的crud操作：

首先我們需要引入依賴

<properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>
    <dependencies>
        <!-- junit單元測試 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
        
        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- spring end -->
        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->
        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->
        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        
        <!-- el beg 使用spring data jpa 必須引入 -->
        <dependency>  
            <groupId>javax.el</groupId>  
            <artifactId>javax.el-api</artifactId>  
            <version>2.2.4</version>  
        </dependency>  
          
        <dependency>  
            <groupId>org.glassfish.web</groupId>  
            <artifactId>javax.el</artifactId>  
            <version>2.2.4</version>  
        </dependency> 
        <!-- el end -->
    </dependencies>

創建spring配置文件applicationContext.xml，使用spring來管理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
	
	<!-- 1.dataSource 配置數據庫連接池-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa?characterEncoding=utf-8" />
		<property name="user" value="root" />
		<property name="password" value="root" />
	</bean>
	
	<!-- 2.配置entityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="com.ithubei.entity" />
		<property name="persistenceProvider">
			<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
		</property>
		<!--JPA的供應商適配器-->
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="generateDdl" value="false" />
				<property name="database" value="MYSQL" />
				<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
				<property name="showSql" value="true" />
			</bean>
		</property>
		<property name="jpaDialect">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
		</property>
	</bean>    
	
	<!-- 3.事務管理器-->
	<!-- JPA事務管理器  -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
	
	<!-- 整合spring data jpa-->
	<jpa:repositories base-package="com.ithubei.dao"
		transaction-manager-ref="transactionManager"
		entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
		
	<!-- 4.txAdvice-->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED"/>
			<tx:method name="insert*" propagation="REQUIRED"/>
			<tx:method name="update*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
			<tx:method name="get*" read-only="true"/>
			<tx:method name="find*" read-only="true"/>
			<tx:method name="*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 5.aop-->
	<aop:config>
		<aop:pointcut id="pointcut" expression="execution(* com.ithubei.service.*.*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
	</aop:config>
	
	<context:component-scan base-package="com.ithubei"></context:component-scan>		
	<!--組裝其它 配置文件-->	
</beans>

創建和數據庫表映射的實體類

package com.ithubei.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
/**
 * 
 *      * 所有的注解都是使用JPA的規范提供的注解，
 *      * 所以在導入注解包的時候，一定要導入javax.persistence下的
 */
@Entity //聲明實體類
@Table(name="cst_customer") //建立實體類和表的映射關系
public class Customer {
    
    @Id//聲明當前私有屬性為主鍵
    @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主鍵的生成策略
    @Column(name="cust_id") //指定和表中cust_id字段的映射關系
    private Long custId;
    
    @Column(name="cust_name") //指定和表中cust_name字段的映射關系
    private String custName;
    
    @Column(name="cust_source")//指定和表中cust_source字段的映射關系
    private String custSource;
    
    @Column(name="cust_industry")//指定和表中cust_industry字段的映射關系
    private String custIndustry;
    
    @Column(name="cust_level")//指定和表中cust_level字段的映射關系
    private String custLevel;
    
    @Column(name="cust_address")//指定和表中cust_address字段的映射關系
    private String custAddress;
    
    @Column(name="cust_phone")//指定和表中cust_phone字段的映射關系
    private String custPhone;
    
    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 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;
    }
}

創建dao層接口CustomerDao，并繼承JpaRepository和JpaSpecificationExecutor接口

/**
 * 定義一個dao層接口，此接口只需要繼承JpaRepository和JpaSpecificationExecutor接口即可，該接口就具備了增刪改	*   查和分頁等功能。
 * JpaRepository<實體類類型，主鍵類型>：完成基本的CRUD操作
 * JpaSpecificationExecutor<實體類類型>:用于復雜查詢（分頁等查詢操作）
 * @author DELL
 *
 */
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer>{
}

dao層編碼已經寫好了，現在我們就可以來測試CustomerDao來實現crud操作。

package com.ithubei.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.ithubei.dao.CustomerDao;
import com.ithubei.entity.Customer;
/**
 * 測試：調用CustomerDao接口完成增刪改查就等操作
 * @author DELL
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class CustomerDaoTest {
	
	@Autowired
	private CustomerDao customerDao;
	
	/**
	 * 保存操作：調用save()方法
	 */
	@Test
	public void testSave() {
		Customer customer = new Customer();
		customer.setCustName("黑馬程序員");
		//保存
		customerDao.save(customer);
	}
	/**
	 * 修改客戶信息：調用save()方法
	 * 	對于save():如果執行此方法時對象中存在id屬性，即為更新操作，會根據id查詢，再更新
	 * 如果此方法中不存在id屬性，則為保存操作
	 */
	@Test
	public void testUpdate() {
		//先根據id查詢id為1的客戶
		Customer customer = customerDao.findOne(96l);
		//修改客戶名稱
		customer.setCustName("授課123");
		//更新
		customerDao.save(customer);
	}
	
	/**
	 * 刪除操作
	 */
	@Test
	public void testDelete() {
		customerDao.delete(96l);
	}
	
	/**
	 * 根據id查詢：調用findOne()
	 */
	@Test
	public void testFindById() {
		Customer customer = customerDao.findOne(97l);
		System.out.println(customer);
	}
}

通過以上測試，我們發現CustomerDao接口下并沒有寫任何的方法，但是它卻具備了crud等操作，只是因為它繼承了JpaRepository和JpaSpecificationExecutor兩個接口，我們就可以使用這兩個接口為我們提供的方法來進行crud等操作。

現在我們就來看一下這兩個接口下的方法列表：

這兩個接口中定義了如此多的方法，方便我們在我們項目中完成基本的操作了。

spring data jpa是一個優勢，它減輕了我們的工作量。所以學會它是每個程序員應該做的事情，建議大家都能夠去學好它。

看完了這篇文章，相信你對“hibernate,jpa與spring data jpa之間有什么關系”有了一定的了解，如果想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！