2. 程式人生 > >Spring實戰——使用物件-關係對映持久化資料

Spring實戰——使用物件-關係對映持久化資料

阿新 • • 發佈：2019-01-13

一、在Spring中整合hibernate

1、hibernate簡介：

      hibernate是目前很流行的開源持久化框架。不僅提供了基本的物件關係對映，還提供了ORM工具所應具有的所有複雜功能，比如快取、延遲載入、預先抓取以及分散式快取。

2、宣告hibernate的Session工廠

在Spring中，需要通過Spring的某一個Hibernate Session工廠bean來獲取Hibernate SessionFactory。從3.1版本開始，Spring提供了三個Session工廠的Bean：

org.springframework.orm.hibernate3.LocalSessionFactoryBean

org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean

org.springframework.orm.hibernate4.LocalSessionFactoryBean

對於以上三個Session工廠，選擇方式如下：

①如果使用hibernate版本在3.2或更高版本（知道hibernate4.0，但不包含4.0），並且使用XML定義對映的話，就使用org.springframework.orm.hibernate3包中的LocalSessionFactoryBean。

②如果使用hibernate版本在3.2或更高版本（知道hibernate4.0，但不包含4.0），並且使用註解定義對映的話，就使用org.springframework.orm.hibernate3.annotation包中的AnnotationSessionFactoryBean。

③如果使用hibernate4，就使用org.springframework.orm.hibernate4.LocalSessionFactoryBean，這個Session工廠既可以匹配XML對映，也可以匹配註解對映。

3、在Spring中整合Hibernate的配置

先在web.xml中新增配置：

    <filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
        <init-param>
            <param-name>singleSession</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

然後在Spring-dao.xml中配置SessionFactory(這裡實體類使用註解對映)：

	<!-- 資料來源連線池配置三種方式（推薦使用）：DBCP、C3P0、BoneCP -->
	<!-- DBCP配置資料來源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:ORCL"></property>
		<property name="username" value="scott"></property>
		<property name="password" value="scott"></property>
	</bean>
	
	<!-- 配置sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="packagesToScan" value="com.mfc.entity"></property>
		<property name="hibernateProperties">
			<props>
                <prop key="hibernate.show_sql">true</prop>     <!--在控制檯顯示執行的資料庫操作語句-->
                <prop key="hibernate.format_sql">true</prop>     <!--在控制檯顯示執行的資料哭操作語句（格式）-->
                <prop key="hibernate.connection.autocommit">true</prop>
			</props>
		</property>
	</bean>

使用Java配置SessionFactory：

	@Bean
	public LocalSessionFactoryBean sessionFactory(DataSource dataSource){
		LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
		sessionFactory.setDataSource(dataSource);
		sessionFactory.setPackagesToScan(new String[]{"com.mfc.entity"});
		Properties properties = new Properties();
		properties.setProperty("hibernate.show_sql", "true");
		properties.setProperty("hibernate.format_sql", "true");
		properties.setProperty("hibernate.connection.autocommit", "true");
		return sessionFactory;
	}

4、在dao層中使用SessionFactory：

以前經常使用HibernateTemplate，HibernateTemplate能夠保證每個事務使用同一個Session，但是這種方式的弊端在於Repository實現會直接與Spring耦合。

先在的最佳實現是使用上下文Session，通過這種方式，會直接將Hibernate的SessionFactory裝配到Repository中，並使用它來獲取Session，程式如下：

package com.mfc.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.mfc.entity.Tuser;

@Repository(value = "tuserDao")
public class TuserDaoImpl implements TuserDao {
	
	@Autowired
	private SessionFactory sessionFactory;
	
	private Session getSession(){
		return sessionFactory.getCurrentSession();
	}
	
	@Override
	public void add(Tuser tuser) {
		getSession().save(tuser);
	}

	@Override
	public void delete(Tuser tuser) {
		getSession().delete(tuser);
	}

	@Override
	public void update(Tuser tuser) {
		getSession().update(tuser);
	}

	@Override
	public List<Tuser> find(Tuser tuser) {
		return getSession().createCriteria(Tuser.class).list();
	}

	@Override
	public Tuser findByPrimary(String userId) {
		return (Tuser) getSession().get(Tuser.class, userId);
	}
}

二、Spring與Java持久化API

1、實體管理器工廠介紹

   基於JPA的應用程式需要使用EntityManagerFactory的實現類來獲取EntityManager例項。JPA定義了兩種型別的實體管理器。

①應用程式管理型別：這種適用於不執行在Java EE容器中的獨立應用程式，不做介紹

②容器管理型別：由JavaEE建立和管理，下面主要看這個。org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

2、使用容器管理型別的JPA

①在Spring容器中注入LocalContainerEntityManagerFactoryBean

	<!-- DBCP配置資料來源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:ORCL"></property>
		<property name="username" value="scott"></property>
		<property name="password" value="scott"></property>
	</bean>
	
	<bean id="em" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="jpaVendorAdapter" ref="jpaVendorAdapter"></property>
		<property name="packagesToScan" value="com.mfc.entity"></property>
	</bean>
	<bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="database" value="ORACLE"></property>
		<property name="showSql" value="true"></property>
		<property name="generateDdl" value="false"></property>
	</bean>

②使用Java配置代替上面的配置：

	@Bean
	public BasicDataSource dataSource(){
		BasicDataSource dataSource = new BasicDataSource();
		dataSource.setDriverClassName("");
		dataSource.setUrl("");
		dataSource.setUsername("");
		dataSource.setPassword("");
		return dataSource;
	}
	
	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource, JpaVendorAdapter jpaVendorAdapter){
		LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
		em.setDataSource(dataSource);
		em.setJpaVendorAdapter(jpaVendorAdapter);
		em.setPackagesToScan(new String[]{"com.mfc.entity"});
		return em;
	}
	
	@Bean
	public JpaVendorAdapter jpaVendorAdapter(){
		HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
		jpaVendorAdapter.setDatabase("ORACLE");
		jpaVendorAdapter.setShowSql(true);
		jpaVendorAdapter.setGenerateDdl(false);
		return jpaVendorAdapter;
	}

③上面程式碼中的jpaVendorAdapter屬性用於指明哪一個廠商的JPA實現，Spring提供了多個JPA廠商介面卡：

EclipseLinkJpaVendorAdapter、HibernateJpaVendorAdapter、OpenJpaVendorAdapter、TopLinkJpaVendorAdapter（已廢棄）

④上面配置中，注入HibernateJpaVendorAdapter時最終啊喲的是database屬性，對應不同資料庫，database屬性的值不同。

Hibernate的JPA介面卡支援多種資料庫，可以通過database的屬性配置使用哪個資料庫
資料庫平臺 屬性database的值
IBM DB2 DB2
Apache Derby DERBY
H2 H2
Hypersonic HSQL
Informix INFORMIX
MySql MYSQL
oracle ORACLE
PostgresQL POSTGRESQL
Microsoft SQL Server SQL SERVER
Sybase SYBASE

3、從JNDI獲取實體管理器工廠

xml配置：

	<jee:jndi-lookup jndi-name="OracleConnection" id="emf"></jee:jndi-lookup>
	
	<bean id="em" class="org.springframework.jndi.JndiObjectFactoryBean">
		<property name="jndiName" value="emf"></property>
	</bean>

Java配置：

    @Bean
	public JndiObjectFactoryBean dataSource(){
		JndiObjectFactoryBean factoryBean = new JndiObjectFactoryBean();
		factoryBean.setJndiName("OracleConnection");
		factoryBean.setProxyInterface(DataSource.class);
		return factoryBean;
	}
    
    @Bean
    public JndiObjectFactoryBean entityManagerFactory(){
    	JndiObjectFactoryBean em = new JndiObjectFactoryBean();
    	em.setJndiName("OracleConnection");
    	return em;
    }

4、使用JPA編寫Dao：

package com.mfc.dao;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.transaction.Transactional;

import org.springframework.stereotype.Repository;

import com.mfc.entity.Tuser;

@Repository(value = "jpaTuserDao")
@Transactional
public class JPATuserDaoImpl implements TuserDao {
	
	@PersistenceContext
	private EntityManager em;

	@Override
	public void add(Tuser tuser) {
		em.persist(tuser);

	}

	@Override
	public void delete(Tuser tuser) {
		em.remove(em.merge(tuser));
	}

	@Override
	public void update(Tuser tuser) {
		em.persist(em.merge(tuser));
	}

	@Override
	public List<Tuser> find(Tuser tuser) {
		String queryString = "select * from tuser";
	    Query query = em.createNativeQuery(queryString,Tuser.class);
	    List<?> result = query.getResultList();
	    List<Tuser> users = new ArrayList<Tuser>();
	    if (result !=null) {
           Iterator<?> iterator =result.iterator();
           while (iterator.hasNext()) {
              Tuser user = (Tuser)iterator.next();
              users.add(user);
           }
        }
	    return users;
	}

	@Override
	public Tuser findByPrimary(String userId) {
		return em.find(Tuser.class, userId);
	}

}

三、藉助SpringData實現自動化的JPA Repository

參考：https://blog.csdn.net/itguangit/article/details/78748077

           https://blog.csdn.net/wu920604/article/details/52595999

以下值記錄了Maven依賴和Spring注入配置，其他具體操作和介紹可以看上面參考的兩篇部落格。

1、這裡注意Spring和Spring Data JPA的版本，我使用的Maven依賴：

  <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <spring.version>4.3.10.RELEASE</spring.version>
  </properties>
  <dependencies>

	 <!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
	<dependency>
	    <groupId>commons-dbcp</groupId>
	    <artifactId>commons-dbcp</artifactId>
	    <version>1.4</version>
	</dependency>
	
    <!-- https://mvnrepository.com/artifact/com.oracle/ojdbc14 -->
	<dependency>
	    <groupId>com.oracle</groupId>
	    <artifactId>ojdbc14</artifactId>
	    <version>10.2.0.1.0</version>
	</dependency>  
	
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
          <!-- springframework 4 dependencies begin -->
         <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>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
       <!--  https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-aspects</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		
		<!-- spring data jpa 資料庫持久層 -->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-jpa</artifactId>
             <version>1.10.4.RELEASE</version>
         </dependency>
        
        <!-- springframework 4 dependencies end -->
        
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
		<dependency>
		    <groupId>org.hibernate</groupId>
		    <artifactId>hibernate-validator</artifactId>
		    <version>4.3.1.Final</version>
		</dependency>
		
		<dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.11.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.11.Final</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.0-api -->
		<dependency>
		    <groupId>org.hibernate.javax.persistence</groupId>
		    <artifactId>hibernate-jpa-2.0-api</artifactId>
		    <version>1.0.1.Final</version>
		</dependency>
        
  </dependencies>
  <build>
    <finalName>SpringInAction7</finalName>
  </build>
</project>

2、Spring-dao.xml配置：

<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.8.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- DBCP配置資料來源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
		<property name="url" value="jdbc:oracle:thin:@localhost:1521:ORCL"></property>
		<property name="username" value="scott"></property>
		<property name="password" value="scott"></property>
	</bean>
	
	<!-- 使用JPA實現持久化配置 -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="jpaVendorAdapter" ref="jpaVendorAdapter"></property>
		<property name="packagesToScan" value="com.mfc.entity"></property>
	</bean>
	<bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="database" value="ORACLE"></property>
		<property name="showSql" value="true"></property>
		<property name="generateDdl" value="false"></property>
	</bean> 
	
	<!-- 配置事務管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
	
	<!-- 測試：使用Spring Data構建自動化的JPA Repository ,com.mfc.SpringDataJPA是Repository介面的包名-->
	<jpa:repositories base-package="com.mfc.SpringDataJPA"></jpa:repositories>
</beans>

 

相關推薦

Spring實戰——使用物件-關係對映持久化資料

一、在Spring中整合hibernate 1、hibernate簡介：       hibernate是目前很流行的開源持久化框架。不僅提供了基本的物件關係對映，還提供了ORM工具所應具有的所有複雜功能，比如快取、延遲載入、預先抓取以及

$Django-setting.py配置 ，GET、POST深入理解，三件套,orm物件關係對映簡介

1 django中app的概念:  大學:----------------- 專案   資訊學院 ----------app01   物理學院-----------app02   ****強調***:建立的每一個app,都要在配置檔案中

使用物件-關係對映 ORM 系統中介軟體提升軟體開發效率及質量

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Hibernate第二篇之瞭解物件關係對映

        今天寫部落格的時候還是想對自己說幾句話，堅持真的是一件很難的事情，你看轉眼幾天過去了，渾渾噩噩的過去了，什麼都沒有幹，突然間就像是斷了線的風箏沒有了方向。我想要自己每個星期都要抽出一點時間來總結這周的學習進度，每天

ORM物件關係對映

ORM ORM 全拼Object-Relation Mapping.物件-關係對映. 主要實現模型物件到關係資料庫資料的對映. 比如：把資料庫表中每條記錄對映為一個模型物件 ORM圖解 // TODO 優點 :

mysql物件關係對映-----ORM

ORM（物件關係對映Object Relation Mapping）簡介 物件關係對映（Object Relational Mapping，簡稱ORM）模式是一種為了解決面向物件與關係資料庫存在的互不匹配的現象的技術。簡言之，ORM是通過使用描述物件和資料庫之間對映 的元資料，把物件模型

hibernate物件關係對映-註解

1.OneToOne關係對映 OneToOne即一對一對映，簡單來說就是一個主表student和一個從表stucreditcard，B表中存在一個外來鍵關聯到student表，這種關聯關係既可以以外來鍵的方式建立也可以是人工維護的關聯關係。 單向一對一關聯（不包括主鍵關聯

帶你手寫一個簡單的ORM框架領悟mybatis,hibernate,jpa物件關係對映的祕密

1、ORM介紹     物件關係對映     解決了一個問題： 物件模型和關係模型之間阻抗。     物件模型                     關係模型     物件名稱 Student             表           t_student     物件

Ｄｊａｎｇｏ核心：元類與ｏｒｍ物件關係對映

元類 ｐｙｔｈｏｎ中所有東西都是物件，包括類也是物件，建立類的類就叫做元類，參考文章深刻理解元類 一個例項 def upper_attr(class_name,class_parents,class_attr): new_attr={} for name,valu

物件關係對映檔案(*.hbm.xml)詳解

物件關係對映檔案，即POJO 類和資料庫的對映檔案*.hbm.xml(對映檔案的副檔名為 .hbm.xml)。 POJO 類和關係資料庫之間的對映可以用一個XML文件來定義。 通過 POJO 類的資料庫對映檔案，Hibernate可以理解持久化類和資料表之間的對

MongoDB Java與物件關係對映

　　MongoDB介紹 　　當今NoSQL領域中有很多有力的競爭者通過多種方式來處理海量資料問題。其中重要的解決方案之一就是MongoDB.MongoDB是面向文件的弱結構化儲存方案，使用JSON格式來展現、查詢和修改資料。 　　MongoDB文件相當完備，擴充套件規模與安裝一樣簡單。它提供冗餘、切片

物件關係對映 ORM

1.1 作用 MTV框架中包括一個重要的部分，它實現了資料模型與資料庫的解耦，即資料模型的設計不需要依賴於特定的資料庫，通過簡單的配置就可以輕鬆更換資料庫，這極大的減輕了開發人員的工作量，不需要面對因資料庫變更而導致的無效勞動 1.2 具體功能 1 建立表，修改表，刪除表 2 插入資

Hibernate4-4 物件關係對映檔案

　　Hibernate根據物件關係對映檔案來理解持久化類和資料表之間的對應關係，也可以理解持久化類屬性與資料庫表字段之間的對應關係，並在執行時生成各種SQL語句。 1. 對映檔案根元素

Hibernate旅程（五）Hibernate對映--基本類對映和物件關係對映

回想一些我們在沒有學習ssh的時候，我們建立資料庫的表時，首先是資料庫建模E-R圖，然後再通過實體模型來建立關係模型，再建立相應的表。實體間存在三種關係，一對一，一對多（或者說多對一），多對多。

ORM物件關係對映之GreenDAO建立多表關聯

利用GreenDAO可以非常方便的建立多張表之間的關聯 一對一關聯 通常我們在操作資料庫的時候，我們往往不是單獨的對一張表進行操作，而是對這張表的操作會聯動的影響另外一張表或者多張表，比如：現在有兩張表，一張是使用者User表（有name、age、sex三個

Django中的ORM（物件關係對映）

Django與資料庫的命令互動主要是通過manage.py，常用的命令就是manage.py syncdb,可以將model中不在資料庫中存在的表給建立完成，但是隻能建立新的資料表或者列，如果model中將某個已經建立的資料表刪除，syncdb是不會進行同步刪除的操作的。

android中ORM(物件關係對映)資料庫greenDAO的使用

    /**     * 查詢儲存的工作資訊     */ private void queryOrganizationInfo() {         DaoSession daoSession = ((MyApplication) getApplication()).getDaoSession();

Hibernate中使用JPA(註解)配置物件關係對映

java中註解也是一大特點，平時進行單元測試時我們用過@Test註解進行測試 JPA就是java專門針對持久層框架進行設計的一套規範 JPA：Java Persistence API，其實它也就是一堆介面，就想JDBC一樣，不同的框架只要遵循這同一套規範就可以在java環境

開源物件關係對映框架hibernate 11大優勢

釋出時間：2009.06.19 11:42 來源：blogjava 作者：Werther Hibernate在解決效能問題方面做得非常好。有了它的快取機制，使用第三方快取和資料庫連線池，就較好的解決的效能問題。但這些還不夠，hibernate給了開發者足夠的自由

【Hibernate框架學習】：Hibernate進階之詳解Hibernate配置檔案和物件關係對映配置檔案

       Hibernate核心配置檔案               我們先來看一個比較常見的hibernate.cfg.xml配置檔案： <!DOCTYPE hibernate-confi