詳談hibernate,jpa與spring?data?jpa三者之間的關(guān)系
更新時間：2021年11月22日 11:09:37 作者：碼@農(nóng)
這篇文章主要介紹了hibernate,jpa與spring?data?jpa三者之間的關(guān)系，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
前提
其實很多框架都是對另一個框架的封裝，我們在學(xué)習類似的框架的時候，難免會進入誤區(qū)，所以我們就應(yīng)該對其進行總結(jié)歸納，對比。本文就是對hibernate，jpa，spring data jpa三者之間進行文字對比，以及對其三者分別進行CRUD操作。
文字說明
Hibernate
Hibernate是一個開放源代碼的對象關(guān)系映射框架，它對JDBC進行了非常輕量級的對象封裝，它將POJO與數(shù)據(jù)庫表建立映射關(guān)系，是一個全自動的orm框架，hibernate可以自動生成SQL語句，自動執(zhí)行，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數(shù)據(jù)庫。
JPA
JPA全稱是Java Persistence API，即java持久化API，是sun公司推出的一套基于ORM的規(guī)范，內(nèi)部由一系列的接口和抽象類構(gòu)成。
JPA與Hibetnate的關(guān)系
JPA和Hibernate的關(guān)系就像JDBC和JDBC驅(qū)動的關(guān)系，JPA是規(guī)范，Hibernate除了作為ORM框架之外，它也是一種JPA實現(xiàn)。JPA怎么取代Hibernate呢？JDBC規(guī)范可以驅(qū)動底層數(shù)據(jù)庫嗎？答案是否定的，也就是說，如果使用JPA規(guī)范進行數(shù)據(jù)庫操作，底層需要hibernate作為其實現(xiàn)類完成數(shù)據(jù)持久化工作。
Spring Data jpa
Spring Data JPA 讓我們解脫了DAO層的操作，基本上所有CRUD都可以依賴于它來實現(xiàn),在實際的工作工程中，推薦使用Spring Data JPA + ORM（如：hibernate）完成操作，這樣在切換不同的ORM框架時提供了極大的方便，同時也使數(shù)據(jù)庫層操作更加簡單，方便解耦
Hibernate、JPA與Spring Data JPA之間的關(guān)系
JPA是一套規(guī)范，內(nèi)部是有接口和抽象類組成的。hibernate是一套成熟的ORM框架，而且Hibernate實現(xiàn)了JPA規(guī)范，所以也可以稱hibernate為JPA的一種實現(xiàn)方式，我們使用JPA的API編程，意味著站在更高的角度上看待問題（面向接口編程）Spring Data JPA是Spring提供的一套對JPA操作更加高級的封裝，是在JPA規(guī)范下的專門用來進行數(shù)據(jù)持久化的解決方案。以上就是對hibernate、JPA與Spring Data JPA三者之間的關(guān)系說明。
總結(jié)：
JPA是一種規(guī)范，Hibernate實現(xiàn)了JPA規(guī)范，即Hibernate為JPA的一種實現(xiàn)；而Spring Data JPA是對JPA進行更高級的封裝，讓其dao編碼變得更簡單。
CRUD操作
hibernate的crud操作
首先創(chuàng)建數(shù)據(jù)庫表
創(chuàng)建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
創(chuàng)建實體類Customer（和數(shù)據(jù)庫表映射的類）
package cn.itcast.domain;
public class Customer
{
private Long cust_id;// '客戶編號(主鍵)',
private String cust_name;// '客戶名稱(公司名稱)',
private String cust_source;// '客戶信息來源',
private String cust_industry;//'客戶所屬行業(yè)',
private String cust_level;// '客戶級別',
private String cust_address;// '客戶聯(lián)系地址',
private String cust_phone;// '客戶聯(lián)系電話',
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;
}
}
創(chuàng)建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)的映射關(guān)系 -->
<hibernate-mapping>
<!--
class標簽: 作用類和表的映射的
name:類的全限定名(cn.itcast.domain.Customer)
table:表的全名(cst_customer)
-->
<class name="cn.itcast.domain.Customer" table="cst_customer">
<!--
id標簽:做類中的某個屬性 和 表的主鍵映射關(guān)系
name:類的某個屬性名
column:表的主鍵字段名
-->
<id name="cust_id" column="cust_id">
<!-- 做主鍵的增長方式的
native: AUTO_INCREMENT 讓主鍵自動增長 -->
<generator class="native"></generator>
</id>
<!--
property標簽:做其它屬性和其它字段的映射關(guān)系
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層的編碼工作?，F(xiàn)在我們來測試：
創(chuàng)建工具類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
// 好處: 在多層之間調(diào)用方法獲取的都是同一個session
public static Session getCurrentSession()
{
/*特點: 1 默認是關(guān)閉的 需要配置開啟
2 會自動給你關(guān)閉連接*/
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的方式來構(gòu)建依賴
首先我們需要引入依賴：
<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目錄下創(chuàng)建META-INF目錄，并在該目錄下創(chuàng)建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：事務(wù)類型
RESOURCE_LOCAL：本地事務(wù)管理
JTA：分布式事務(wù)管理 -->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--配置JPA規(guī)范的服務(wù)提供商 -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- 數(shù)據(jù)庫驅(qū)動 -->
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
<!-- 數(shù)據(jù)庫地址 -->
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?characterEncoding=utf-8" />
<!-- 數(shù)據(jù)庫用戶名 -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- 數(shù)據(jù)庫密碼 -->
<property name="javax.persistence.jdbc.password" value="root" />
<!--jpa提供者的可選配置：我們的JPA規(guī)范的提供者為hibernate，所以jpa的核心配置中兼容hibernate的 -->
<!--配置jpa實現(xiàn)方(hibernate)的配置信息
顯示sql ： false|true
自動創(chuàng)建數(shù)據(jù)庫表 ： hibernate.hbm2ddl.auto
create : 程序運行時創(chuàng)建數(shù)據(jù)庫表（如果有表，先刪除表再創(chuàng)建）
update ：程序運行時創(chuàng)建表（如果有表，不會創(chuàng)建表）
none ：不會創(chuàng)建表
-->
<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>
創(chuàng)建和數(shù)據(jù)庫表映射的實體類
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
作用：指定實體類和表之間的對應(yīng)關(guān)系。
屬性：
name：指定數(shù)據(jù)庫表的名稱
@Id
作用：指定當前字段是主鍵。
@GeneratedValue
作用：指定主鍵的生成方式。。
屬性：
strategy ：指定主鍵生成策略。
@Column
作用：指定實體類屬性和數(shù)據(jù)庫表之間的對應(yīng)關(guān)系
屬性：
name：指定數(shù)據(jù)庫表的列名稱。
unique：是否唯一
nullable：是否可以為空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定義建表時創(chuàng)建此列的DDL
secondaryTable: 從表名。如果此列不建在主表上（默認建在主表），該屬性定義該列所在從表的名字搭建開發(fā)環(huán)境[重點]
* @author DELL
*
*/
@Entity //聲明該類是和數(shù)據(jù)庫表映射的實體類
@Table(name="cst_customer") //建立實體類與表的映射關(guān)系
public class Customer implements Serializable{
@Id //聲明當前私有屬性為主鍵
@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主鍵的生成策略，為自增主鍵
@Column(name = "cust_id")
private Long custId;
@Column(name="cust_name") //指定和表中cust_name字段的映射關(guān)系
private String custName;
@Column(name="cust_source") //指定和表中cust_source字段的映射關(guān)系
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;
}
}
創(chuàng)建工具類JpaUtils
package com.ithubei.utils;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
/**
* 解決實體管理器工廠的浪費資源和耗時問題
* 通過靜態(tài)代碼塊的形式，當程序第一次訪問此工具類時，創(chuàng)建一個公共的實體管理器工廠對象
*
* 第一次訪問getEntityManager方法：經(jīng)過靜態(tài)代碼塊創(chuàng)建一個factory對象，再調(diào)用方法創(chuàng)建一個EntityManager對象
* 第二次方法getEntityManager方法：直接通過一個已經(jīng)創(chuàng)建好的factory對象，創(chuàng)建EntityManager對象
*/
public class JpaUtils {
private static EntityManagerFactory entityManagerFactory;
static {
//1.加載配置文件，創(chuàng)建entityManagerFactory
entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
}
public static EntityManager getEntityManager() {
return entityManagerFactory.createEntityManager();
}
}
通過以上工具類，我們就可以得到EntityManager實體管理類來進行crud等操作。
在 JPA 規(guī)范中, EntityManager是完成持久化操作的核心對象。實體類作為普通 java對象，只有在調(diào)用 EntityManager將其持久化后才會變成持久化對象。EntityManager對象在一組實體類與底層數(shù)據(jù)源之間進行 O/R 映射的管理。它可以用來管理和更新 Entity Bean, 根椐主鍵查找 Entity Bean, 還可以通過JPQL語句查詢實體。
我們可以通過調(diào)用EntityManager的方法完成獲取事務(wù)，以及持久化數(shù)據(jù)庫的操作。
方法說明：
getTransaction：獲取事務(wù)對象persist：保存操作merge：更新操作remove：刪除操作find（立即加載）/getReference（延遲加載）：根據(jù)id查詢
現(xiàn)在我們就來通過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();
//獲取事務(wù)對象
EntityTransaction tx = em.getTransaction();
tx.begin(); //開啟事務(wù)
//完成增刪改查操作，保存一個用戶到數(shù)據(jù)庫中
Customer customer = new Customer();
customer.setCustName("授課");
customer.setCustIndustry("教育");
//保存操作
em.persist(customer);
tx.commit(); //提交事務(wù)
em.close(); //釋放資源
}
/**
* 保存一個實體
*/
@Test
public void testAdd() {
// 定義對象
Customer c = new Customer();
c.setCustName("傳智學(xué)院");
c.setCustLevel("VIP客戶");
c.setCustSource("網(wǎng)絡(luò)");
c.setCustIndustry("IT教育");
c.setCustAddress("昌平區(qū)北七家鎮(zhèn)");
c.setCustPhone("010-84389340");
EntityManager em = null;
EntityTransaction tx = null;
try {
// 獲取實體管理對象
em = JpaUtils.getEntityManager();
// 獲取事務(wù)對象
tx = em.getTransaction();
// 開啟事務(wù)
tx.begin();
// 執(zhí)行操作
em.persist(c);
// 提交事務(wù)
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
/**
* 修改操作
*/
@Test
public void testMerge(){
//定義對象
EntityManager em=null;
EntityTransaction tx=null;
try{
//獲取實體管理對象
em=JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx=em.getTransaction();
//開啟事務(wù)
tx.begin();
//執(zhí)行操作
Customer c1 = em.find(Customer.class, 6L);
c1.setCustName("江蘇傳智學(xué)院");
em.clear();//把c1對象從緩存中清除出去
em.merge(c1);
//提交事務(wù)
tx.commit();
}catch(Exception e){
//回滾事務(wù)
tx.rollback();
e.printStackTrace();
}finally{
//釋放資源
em.close();
}
}
/**
* 刪除操作
*/
@Test
public void testRemove() {
// 定義對象
EntityManager em = null;
EntityTransaction tx = null;
try {
// 獲取實體管理對象
em = JpaUtils.getEntityManager();
// 獲取事務(wù)對象
tx = em.getTransaction();
// 開啟事務(wù)
tx.begin();
// 執(zhí)行操作
Customer c1 = em.find(Customer.class, 6L);
em.remove(c1);
// 提交事務(wù)
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
/**
* 查詢操作find()
*/
@Test
public void testGetOne() {
// 定義對象
EntityManager em = null;
EntityTransaction tx = null;
try {
// 獲取實體管理對象
em = JpaUtils.getEntityManager();
// 獲取事務(wù)對象
tx = em.getTransaction();
// 開啟事務(wù)
tx.begin();
// 執(zhí)行操作
Customer c1 = em.find(Customer.class, 96);
// 提交事務(wù)
tx.commit();
System.out.println(c1); // 輸出查詢對象
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
}
雖然我們已經(jīng)使用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持久化查詢語言）來查詢數(shù)據(jù)
* @author DELL
*
*/
public class JpqlTest {
/**
* 查詢?nèi)康目蛻?
*/
@Test
public void findAll() {
EntityManager em = null;
EntityTransaction tx = null;
try {
//獲取是管理對象
em = JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx = em.getTransaction();
//開啟事務(wù)
tx.begin();
String jpql = "from Customer";
//創(chuàng)建query對象
Query query = em.createQuery(jpql);
//使用query對象查詢客戶信息
List list = query.getResultList(); //查詢所有的客戶
for (Object object : list) {
System.out.println(object);
}
//提交事務(wù)
tx.commit();
}catch (Exception e) {
// TODO: handle exception
//發(fā)生異常進行回滾
tx.rollback();
e.printStackTrace();
}finally {
//釋放資源
em.close();
}
}
//分頁查詢客戶
@Test
public void findPaged () {
EntityManager em = null;
EntityTransaction tx = null;
try {
//獲取實體管理對象
em = JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx = em.getTransaction();
tx.begin();
//創(chuàng)建query對象
String jpql = "from Customer";
Query query = em.createQuery(jpql);
//起始索引
query.setFirstResult(0);
//每頁顯示條數(shù)
query.setMaxResults(2);
//查詢并得到返回結(jié)果
List list = query.getResultList(); //得到集合返回類型
for (Object object : list) {
System.out.println(object);
}
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
//條件查詢
@Test
public void findCondition () {
EntityManager em = null;
EntityTransaction tx = null;
try {
//獲取實體管理對象
em = JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx = em.getTransaction();
tx.begin();
//創(chuàng)建query對象
String jpql = "from Customer where custName like ? ";
Query query = em.createQuery(jpql);
//對占位符賦值，從1開始
query.setParameter(1, "傳智%");
//查詢并得到返回結(jié)果
Object object = query.getSingleResult(); //得到唯一的結(jié)果集對象
System.out.println(object);
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
//根據(jù)客戶id倒序查詢所有客戶
//查詢所有客戶
@Test
public void testOrder() {
EntityManager em = null;
EntityTransaction tx = null;
try {
//獲取實體管理對象
em = JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx = em.getTransaction();
tx.begin();
// 創(chuàng)建query對象
String jpql = "from Customer order by custId desc";
Query query = em.createQuery(jpql);
// 查詢并得到返回結(jié)果
List list = query.getResultList(); // 得到集合返回類型
for (Object object : list) {
System.out.println(object);
}
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
//統(tǒng)計查詢
@Test
public void findCount() {
EntityManager em = null;
EntityTransaction tx = null;
try {
//獲取實體管理對象
em = JpaUtils.getEntityManager();
//獲取事務(wù)對象
tx = em.getTransaction();
tx.begin();
// 查詢?nèi)靠蛻?
// 1.創(chuàng)建query對象
String jpql = "select count(custId) from Customer";
Query query = em.createQuery(jpql);
// 2.查詢并得到返回結(jié)果
Object count = query.getSingleResult(); // 得到集合返回類型
System.out.println(count); //客戶人數(shù)
tx.commit();
} catch (Exception e) {
// 回滾事務(wù)
tx.rollback();
e.printStackTrace();
} finally {
// 釋放資源
em.close();
}
}
}
通過以上等操作，我們就完成了JPA的crud操作。
接下來我們就開始使用spring data jpa來完成crud操作，讓我們體會一下什么叫優(yōu)勢。
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>
創(chuàng)建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 配置數(shù)據(jù)庫連接池--> <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的供應(yīng)商適配器--> <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.事務(wù)管理器--> <!-- JPA事務(wù)管理器 --> <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>
創(chuàng)建和數(shù)據(jù)庫表映射的實體類
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的規(guī)范提供的注解，
* * 所以在導(dǎo)入注解包的時候，一定要導(dǎo)入javax.persistence下的
*/
@Entity //聲明實體類
@Table(name="cst_customer") //建立實體類和表的映射關(guān)系
public class Customer {
@Id//聲明當前私有屬性為主鍵
@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主鍵的生成策略
@Column(name="cust_id") //指定和表中cust_id字段的映射關(guān)系
private Long custId;
@Column(name="cust_name") //指定和表中cust_name字段的映射關(guān)系
private String custName;
@Column(name="cust_source")//指定和表中cust_source字段的映射關(guān)系
private String custSource;
@Column(name="cust_industry")//指定和表中cust_industry字段的映射關(guān)系
private String custIndustry;
@Column(name="cust_level")//指定和表中cust_level字段的映射關(guān)系
private String custLevel;
@Column(name="cust_address")//指定和表中cust_address字段的映射關(guān)系
private String custAddress;
@Column(name="cust_phone")//指定和表中cust_phone字段的映射關(guān)系
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;
}
}
創(chuàng)建dao層接口CustomerDao，并繼承JpaRepository和JpaSpecificationExecutor接口
/**
* 定義一個dao層接口，此接口只需要繼承JpaRepository和JpaSpecificationExecutor接口即可，該接口就具備了增刪改 * 查和分頁等功能。
* JpaRepository<實體類類型，主鍵類型>：完成基本的CRUD操作
* JpaSpecificationExecutor<實體類類型>:用于復(fù)雜查詢（分頁等查詢操作）
* @author DELL
*
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer>{
}
dao層編碼已經(jīng)寫好了，現(xiàn)在我們就可以來測試CustomerDao來實現(xiàn)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;
/**
* 測試：調(diào)用CustomerDao接口完成增刪改查就等操作
* @author DELL
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
/**
* 保存操作：調(diào)用save()方法
*/
@Test
public void testSave() {
Customer customer = new Customer();
customer.setCustName("黑馬程序員");
//保存
customerDao.save(customer);
}
/**
* 修改客戶信息：調(diào)用save()方法
* 對于save():如果執(zhí)行此方法時對象中存在id屬性，即為更新操作，會根據(jù)id查詢，再更新
* 如果此方法中不存在id屬性，則為保存操作
*/
@Test
public void testUpdate() {
//先根據(jù)id查詢id為1的客戶
Customer customer = customerDao.findOne(96l);
//修改客戶名稱
customer.setCustName("授課123");
//更新
customerDao.save(customer);
}
/**
* 刪除操作
*/
@Test
public void testDelete() {
customerDao.delete(96l);
}
/**
* 根據(jù)id查詢：調(diào)用findOne()
*/
@Test
public void testFindById() {
Customer customer = customerDao.findOne(97l);
System.out.println(customer);
}
}
通過以上測試，我們發(fā)現(xiàn)CustomerDao接口下并沒有寫任何的方法，但是它卻具備了crud等操作，只是因為它繼承了JpaRepository和JpaSpecificationExecutor兩個接口，我們就可以使用這兩個接口為我們提供的方法來進行crud等操作。
現(xiàn)在我們就來看一下這兩個接口下的方法列表：
這兩個接口中定義了如此多的方法，方便我們在我們項目中完成基本的操作了。
spring data jpa是一個優(yōu)勢，它減輕了我們的工作量。所以學(xué)會它是每個程序員應(yīng)該做的事情，建議大家都能夠去學(xué)好它。
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。
相關(guān)文章
這篇文章主要介紹了Java延遲隊列DelayQueue原理詳解,DelayQueue 是一個通過PriorityBlockingQueue實現(xiàn)延遲獲取元素的無界隊列無界阻塞隊列,其中添加進該隊列的元素必須實現(xiàn)Delayed接口,而且只有在延遲期滿后才能從中提取元素,需要的朋友可以參考下2023-12-12
大家好，本篇文章主要講的是JAVALambda表達式與函數(shù)式接口詳解，感興趣的同學(xué)趕快來看一看吧，對你有幫助的話記得收藏一下2022-02-02
這篇文章主要為大家詳細介紹了java版數(shù)獨游戲界面實現(xiàn)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-12-12
下面小編就為大家?guī)硪黄猨ava中簡單的截取分割字符串實例。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-03-03
這篇文章主要為大家詳細介紹了java實現(xiàn)隨機驗證碼圖片生成，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-11-11
Springboot整合第三方登錄功能的實現(xiàn)示例
本文主要介紹了Springboot整合第三方登錄功能的實現(xiàn)示例，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-01-01
安全管理是軟件系統(tǒng)必不可少的的功能。根據(jù)經(jīng)典的“墨菲定律”——凡是可能，總會發(fā)生。如果系統(tǒng)存在安全隱患，最終必然會出現(xiàn)問題，這篇文章主要介紹了SpringBoot集成JWT、Shiro框架的使用2022-12-12
springboot3+r2dbc響應(yīng)式編程實踐
本文主要介紹了springboot3+r2dbc響應(yīng)式編程實踐，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-02-02
java、spring、springboot中整合Redis的詳細講解
這篇文章主要介紹了java、spring、springboot中整合Redis的詳細講解，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習或者工作具有一定的參考學(xué)習價值，需要的朋友們下面隨著小編來一起學(xué)習學(xué)習吧2021-04-04
Java中高效判斷數(shù)組中是否包含某個元素的幾種方法
這是一個在Java中經(jīng)常用到的并且非常有用的操作，這個問題在Stack Overflow中也是一個非常熱門的問題，本文將分析幾種常見用法及其時間成本2021-09-09