日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Spring數(shù)據(jù)庫訪問之ORM

Spring數(shù)據(jù)庫訪問中另外一大模塊就是ORM，ORM即對象/關(guān)系映射。Spring支持大多數(shù)ORM框架，比如Hibernate，JPA，JDO，TopLink和iBatis(Spring2支持iBatis2，現(xiàn)MyBatis3的Spring支持由MyBatis社區(qū)開發(fā)，并非Spring)。

成都創(chuàng)新互聯(lián)公司是由多位在大型網(wǎng)絡(luò)公司、廣告設(shè)計(jì)公司的優(yōu)秀設(shè)計(jì)人員和策劃人員組成的一個具有豐富經(jīng)驗(yàn)的團(tuán)隊(duì)，其中包括網(wǎng)站策劃、網(wǎng)頁美工、網(wǎng)站程序員、網(wǎng)頁設(shè)計(jì)師、平面廣告設(shè)計(jì)師、網(wǎng)絡(luò)營銷人員及形象策劃。承接：網(wǎng)站制作、成都網(wǎng)站制作、網(wǎng)站改版、網(wǎng)頁設(shè)計(jì)制作、網(wǎng)站建設(shè)與維護(hù)、網(wǎng)絡(luò)推廣、數(shù)據(jù)庫開發(fā),以高性價(jià)比制作企業(yè)網(wǎng)站、行業(yè)門戶平臺等全方位的服務(wù)。

首先我們從單獨(dú)使用ORM框架開始，來介紹Spring對ORM的支持，以Hibernate為例。使用ORM框架，需要提供持久化類，以課程管理為背景，如下設(shè)計(jì)課程類：

Java代碼

 
 
 
 
    
  
  
  
  
  1. public class Course {    
    2. 
  
  
  
  
  2.   private Long id;    
    3. 
  
  
  
  
  3.   private String title;    
    4. 
  
  
  
  
  4.   private java.util.Date startDate;    
    5. 
  
  
  
  
  5.   private java.util.Date endDate;    
    6. 
  
  
  
  
  6.   private int fee;    
    7. 
  
  
  
  
  7.   //必須提供無參默認(rèn)構(gòu)造方法    
    8. 
  
  
  
  
  8.   public Course() {    
    9. 
  
  
  
  
  9.       super();    
    10. 
  
  
  
  
  10.   }    
    11. 
  
  
  
  
  11.   //省略其它構(gòu)造方法，getter和setter等方法    
    12. 
  
  
  
  
  12.   
    13.

作為對數(shù)據(jù)訪問的一種模式，我們?nèi)匀粦?yīng)用DAO模式，寫DAO類已經(jīng)很熟練了，如下設(shè)計(jì)即可：

 
 
 
 
    
  
  
  
  
  1. package org.ourpioneer.course.dao;    
    2. 
  
  
  
  
  2. import java.util.List;    
    3. 
  
  
  
  
  3. import org.ourpioneer.course.bean.Course;    
    4. 
  
  
  
  
  4. public interface CourseDAO {    
    5. 
  
  
  
  
  5.     public void save(Course course);    
    6. 
  
  
  
  
  6.     public void delete(Course course);    
    7. 
  
  
  
  
  7. public void update(Course course);    
    8. 
  
  
  
  
  8.     public Course findById(Long courseId);    
    9. 
  
  
  
  
  9.     public List  findAll();      
    10. 
  
  
  
  
  10. }   
    11.

非常簡單的設(shè)計(jì)，包含CRUD操作，那么實(shí)現(xiàn)類中我們用Hibernate幫助我們進(jìn)行數(shù)據(jù)庫訪問操作也非常簡單：

 
 
 
 
    
  
  
  
  
  1. package org.ourpioneer.course.dao;    
    2. 
  
  
  
  
  2. import java.util.List;    
    3. 
  
  
  
  
  3. import org.hibernate.Query;    
    4. 
  
  
  
  
  4. import org.hibernate.Session;    
    5. 
  
  
  
  
  5. import org.hibernate.SessionFactory;    
    6. 
  
  
  
  
  6. import org.hibernate.Transaction;    
    7. 
  
  
  
  
  7. import org.hibernate.cfg.Configuration;    
    8. 
  
  
  
  
  8. import org.ourpioneer.course.bean.Course;    
    9. 
  
  
  
  
  9. public class CourseDAOImpl implements CourseDAO {    
    10. 
  
  
  
  
  10.     private SessionFactory sessionFactory;    
    11. 
  
  
  
  
  11.     public CourseDAOImpl() {    
    12. 
  
  
  
  
  12.         Configuration cfg = new Configuration().configure();    
    13. 
  
  
  
  
  13.         sessionFactory = cfg.buildSessionFactory();    
    14. 
  
  
  
  
  14.     }    
    15. 
  
  
  
  
  15.     public List  findAll() {      
    16. 
  
  
  
  
  16.         Session session = sessionFactory.openSession();    
    17. 
  
  
  
  
  17.         try {    
    18. 
  
  
  
  
  18.             Query query = session.createQuery("from Course");    
    19. 
  
  
  
  
  19.             return query.list();    
    20. 
  
  
  
  
  20.         } finally {    
    21. 
  
  
  
  
  21.             session.close();    
    22. 
  
  
  
  
  22.         }    
    23. 
  
  
  
  
  23.     }    
    24. 
  
  
  
  
  24.     public Course findById(Long courseId) {    
    25. 
  
  
  
  
  25.         Session session = sessionFactory.openSession();    
    26. 
  
  
  
  
  26.         try {    
    27. 
  
  
  
  
  27.             return (Course) session.get(Course.class, courseId);    
    28. 
  
  
  
  
  28.         } finally {    
    29. 
  
  
  
  
  29.             session.close();    
    30. 
  
  
  
  
  30.         }    
    31. 
  
  
  
  
  31.     }    
    32. 
  
  
  
  
  32.     public void save(Course course) {    
    33. 
  
  
  
  
  33.         Session session = sessionFactory.openSession();    
    34. 
  
  
  
  
  34.         Transaction tx = session.beginTransaction();    
    35. 
  
  
  
  
  35.         try {    
    36. 
  
  
  
  
  36.             tx.begin();    
    37. 
  
  
  
  
  37.             session.saveOrUpdate(course);    
    38. 
  
  
  
  
  38.             tx.commit();    
    39. 
  
  
  
  
  39.         } catch (RuntimeException e) {    
    40. 
  
  
  
  
  40.             tx.rollback();    
    41. 
  
  
  
  
  41.             throw e;    
    42. 
  
  
  
  
  42.         } finally {    
    43. 
  
  
  
  
  43.             session.close();    
    44. 
  
  
  
  
  44.         }    
    45. 
  
  
  
  
  45.     }    
    46. 
  
  
  
  
  46. }  
    47.

這里只展示幾個方法作為代表，其它方法類似可以寫出，非常簡單。首先是構(gòu)造方法，初始化實(shí)現(xiàn)類時創(chuàng)建Hibernate的配置對象，new Configuration().configure()時，Hibernate會在類路徑的根路徑下自動尋找名為hibernate.cfg.xml的配置文件并加載，之后就是創(chuàng)建Hibernate的Session對象，利用Session對象提供和衍生出的方法來進(jìn)行數(shù)據(jù)庫操作。下面來看配置文件，這是比較重要的，因?yàn)橥ㄟ^配置文件，把數(shù)據(jù)庫信息和實(shí)體Bean的信息都告訴Hibernate，可以省去我們很多在數(shù)據(jù)庫設(shè)計(jì)上的事情。

 
 
 
 
    
  
  
  
  
  1.  xml version='1.0' encoding='UTF-8'?>   
    2. 
  
  
  
  
  2. 
  
  
  
  
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    
    4. 
  
  
  
  
  4.   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">   
    5. 
  
  
  
  
  5.    
    6. 
  
  
  
  
  6.        
    7. 
  
  
  
  
  7.         com.mysql.jdbc.Driver property>   
    8. 
  
  
  
  
  8.         jdbc:mysql:///test property>   
    9. 
  
  
  
  
  9.         root property>   
    10. 
  
  
  
  
  10.         123 property>   
    11. 
  
  
  
  
  11.         org.hibernate.dialect.MySQLDialect property>   
    12. 
  
  
  
  
  12.         true property>   
    13. 
  
  
  
  
  13.         update property>   
    14. 
  
  
  
  
  14.            
    15. 
  
  
  
  
  15.      session-factory>   
    16. 
  
  
  
  
  16.  hibernate-configuration>   
    17.

這里我們告訴Hibernate使用mysql數(shù)據(jù)庫，并配置數(shù)據(jù)庫信息，所用方言，并在執(zhí)行應(yīng)用程序時在控制臺打印出還原的SQL語句。使用hbm2ddl.auto可以讓Hibernate根據(jù)實(shí)體Bean的配置信息來自動建表，這是很方便的，最后的mapping就是配置實(shí)體bean映射信息的文件，我們來看一下：

 
 
 
 
    
  
  
  
  
  1.  xml version="1.0" encoding="UTF-8"?>   
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">   
    4. 
  
  
  
  
  4.    
    5. 
  
  
  
  
  5.        
    6. 
  
  
  
  
  6.            
    7. 
  
  
  
  
  7.                
    8. 
  
  
  
  
  8.          id>   
    9. 
  
  
  
  
  9.         
  
  
  
  
  10.             length="100" not-null="true" />   
    11. 
  
  
  
  
  11.         
  
  
  
  
  12.             not-null="true" />   
    13. 
  
  
  
  
  13.         
  
  
  
  
  14.             not-null="true" />   
    15. 
  
  
  
  
  15.         
  
  
  
  
  16.             not-null="true" />   
    17. 
  
  
  
  
  17.      class>   
    18. 
  
  
  
  
  18.  hibernate-mapping>   
    19.

這里首先配置了實(shí)體bean的所在位置，類信息還有數(shù)據(jù)庫中表對應(yīng)的關(guān)系。之后創(chuàng)建主鍵信息id，使用了MySQL的自增主鍵特性，剩下就是對各個字段的描述了，都見名知意，易于理解。

準(zhǔn)備好這些內(nèi)容，就可以編寫測試程序了，在項(xiàng)目中引入Hibernate的相關(guān)依賴。這里說明一下，Maven默認(rèn)倉庫是Apache的，其中的Hibernate版本還在3.3.2.GA(本文編寫時)，而當(dāng)前的Hibernate官方版本已經(jīng)是3.6.0.Final了，我們想使用新版本，該怎么辦?很簡單，配置Maven倉庫的位置，讓其可以發(fā)現(xiàn)3.6.0.Final版的Hibernate并下載依賴。JBoss官方也提供一個Maven倉庫，其中就有最新版的Hibernate，那么我們在項(xiàng)目的POM中配置一下這個地址：

 
 
 
 
    
  
  
  
  
  1.    
    2. 
  
  
  
  
  2.        
    3. 
  
  
  
  
  3.            
    4. 
  
  
  
  
  4.             always updatePolicy>   
    5. 
  
  
  
  
  5.          releases>   
    6. 
  
  
  
  
  6.            
    7. 
  
  
  
  
  7.             always updatePolicy>   
    8. 
  
  
  
  
  8.          snapshots>   
    9. 
  
  
  
  
  9.         Jboss id>   
    10. 
  
  
  
  
  10.         Jboss Repository name>   
    11. 
  
  
  
  
  11. https://repository.jboss.org/nexus/content/groups/public url>   
    12. 
  
  
  
  
  12.      repository>   
    13. 
  
  
  
  
  13.  repositories>   
    14.

之后，為項(xiàng)目引入其它必要的依賴，使用Maven管理，我們不需自己再去尋找各種依賴了，非常簡單的管理，如圖所示：

下面來看示例程序：

 
 
 
 
    
  
  
  
  
  1. package org.ourpioneer.course;    
    2. 
  
  
  
  
  2. import java.util.GregorianCalendar;    
    3. 
  
  
  
  
  3. import java.util.List;    
    4. 
  
  
  
  
  4. import org.ourpioneer.course.bean.Course;    
    5. 
  
  
  
  
  5. import org.ourpioneer.course.dao.CourseDAO;    
    6. 
  
  
  
  
  6. import org.ourpioneer.course.dao.CourseDAOImpl;    
    7. 
  
  
  
  
  7. public class Demo {    
    8. 
  
  
  
  
  8.     public static void main(String[] args) {    
    9. 
  
  
  
  
  9.         CourseDAO courseDAO = new CourseDAOImpl();    
    10. 
  
  
  
  
  10.         Course course = new Course();    
    11. 
  
  
  
  
  11.         course.setTitle("Spring ORM");    
    12. 
  
  
  
  
  12.         course.setStartDate(new GregorianCalendar(2011, 1, 1).getTime());    
    13. 
  
  
  
  
  13.         course.setEndDate(new GregorianCalendar(2011, 2, 1).getTime());    
    14. 
  
  
  
  
  14.         course.setFee(100);    
    15. 
  
  
  
  
  15.         courseDAO.save(course);    
    16. 
  
  
  
  
  16.         List  courses = courseDAO.findAll();      
    17. 
  
  
  
  
  17.         Long courseId = courses.get(0).getId();    
    18. 
  
  
  
  
  18.         course = courseDAO.findById(courseId);    
    19. 
  
  
  
  
  19.         System.out.println(course);    
    20. 
  
  
  
  
  20.         courseDAO.delete(course);    
    21. 
  
  
  
  
  21.     }    
    22. 
  
  
  
  
  22. }   
    23.

首先創(chuàng)建的是Course對象，并設(shè)置其中的屬性，使用save方法將其持久化到數(shù)據(jù)庫中，之后通過findAll方法查詢數(shù)據(jù)庫中的全部記錄，當(dāng)然現(xiàn)在只有一條。并拿到Id，在通過findById方法獲取出來，然后打印結(jié)果。最終刪除記錄。執(zhí)行該程序，我們可以得到如下輸出信息：

我們之前并沒有在數(shù)據(jù)庫中建表，而Hibernate在執(zhí)行插入之前會為我們自動建表，然后執(zhí)行插入操作，兩次查詢操作，并打印出對象信息，最后執(zhí)行了刪除操作，從SQL語句中可以看到Hibernate最終的執(zhí)行結(jié)果是什么。而此時回到數(shù)據(jù)庫中，會發(fā)現(xiàn)一個建好的表。

Hibernate的簡單ORM映射操作就介紹完了，下面來看使用JPA注解和Hibernate的API來持久化對象，首先修改持久化類：

 
 
 
 
    
  
  
  
  
  1. package org.ourpioneer.course.bean;    
    2. 
  
  
  
  
  2. import java.sql.Date;    
    3. 
  
  
  
  
  3. import javax.persistence.Column;    
    4. 
  
  
  
  
  4. import javax.persistence.Entity;    
    5. 
  
  
  
  
  5. import javax.persistence.GeneratedValue;    
    6. 
  
  
  
  
  6. import javax.persistence.GenerationType;    
    7. 
  
  
  
  
  7. import javax.persistence.Id;    
    8. 
  
  
  
  
  8. import javax.persistence.Table;    
    9. 
  
  
  
  
  9.    
    10. 
  
  
  
  
  10. /**   
    11. 
  
  
  
  
  11.  * 課程信息描述bean   
    12. 
  
  
  
  
  12.  *    
    13. 
  
  
  
  
  13.  * @author Nanlei   
    14. 
  
  
  
  
  14.  *    
    15. 
  
  
  
  
  15.  */   
    16. 
  
  
  
  
  16. @Entity   
    17. 
  
  
  
  
  17. @Table(name = "course")    
    18. 
  
  
  
  
  18. public class Course {    
    19. 
  
  
  
  
  19.     @Id   
    20. 
  
  
  
  
  20.     @GeneratedValue(strategy = GenerationType.IDENTITY)    
    21. 
  
  
  
  
  21.     @Column(name = "ID")    
    22. 
  
  
  
  
  22.     private Long id;    
    23. 
  
  
  
  
  23.     @Column(name = "TITLE", length = 100, nullable = false)    
    24. 
  
  
  
  
  24.     private String title;    
    25. 
  
  
  
  
  25.     @Column(name = "STARTDATE",nullable=false)    
    26. 
  
  
  
  
  26.     private java.util.Date startDate;    
    27. 
  
  
  
  
  27.     @Column(name = "ENDDATE",nullable=false)    
    28. 
  
  
  
  
  28.     private java.util.Date endDate;    
    29. 
  
  
  
  
  29.     @Column(name = "FEE",nullable=false)    
    30. 
  
  
  
  
  30.     private int fee;    
    31. 
  
  
  
  
  31.     // 其余內(nèi)容不變，省略    
    32. 
  
  
  
  
  32. }  
    33.

使用JPA的注解，首先對類進(jìn)行注解，使用@Entity，并關(guān)聯(lián)數(shù)據(jù)庫表，使用@Table。下面就是對字段進(jìn)行主鍵了，標(biāo)識符（主鍵）字段要使用@Id，還要指定生成策略和對應(yīng)的列名，剩下的字段只需指定列信息即可?，F(xiàn)在告訴Hibernate我們使用JPA注解，而不使用映射文件了，如下配置：

 
 
 
 
    
  
  
  
  
  1.     
    2. 
  
  
  
  
  2.    
    3.

修改DAO實(shí)現(xiàn)類的構(gòu)造方法，使用注解配置方式創(chuàng)建SessionFactory，如下即可：

 
 
 
 
    
  
  
  
  
  1. public CourseDAOImpl() {    
    2. 
  
  
  
  
  2.     // Configuration cfg = new Configuration().configure();    
    3. 
  
  
  
  
  3.     Configuration cfg = new AnnotationConfiguration().configure();    
    4. 
  
  
  
  
  4.     sessionFactory = cfg.buildSessionFactory();    
    5. 
  
  
  
  
  5. }   
    6.

此時再次執(zhí)行測試方法，反饋的信息沒有任何變化，但是我們就使用了JPA注解而并非Hibernate的映射信息了。下面來看看使用Hibernate作為JPA引擎的持久化步驟。先配置依賴，引入：

 
 
 
 
    
  
  
  
  
  1.    
    2. 
  
  
  
  
  2.     org.hibernate groupId>   
    3. 
  
  
  
  
  3.     hibernate-entitymanager artifactId>   
    4. 
  
  
  
  
  4.     3.6.0.Final version>   
    5. 
  
  
  
  
  5.     jar type>   
    6. 
  
  
  
  
  6.     compile scope>   
    7. 
  
  
  
  
  7.  dependency>   
    8. 
  
  
  
  
  8.    
    9. 
  
  
  
  
  9.     jboss groupId>   
    10. 
  
  
  
  
  10.     jboss-archive-browsing artifactId>   
    11. 
  
  
  
  
  11.     5.0.0alpha-200607201-119 version>   
    12. 
  
  
  
  
  12.     jar type>   
    13. 
  
  
  
  
  13.     compile scope>   
    14. 
  
  
  
  
  14.  dependency>  
    15.

如果在Java EE容器中運(yùn)行JPA，可以通過容器來配置JPA，如果是在Java SE中運(yùn)行JPA，那么需要在類路徑的META-INF下配置persistence.xml來配置持久化單元，在本例中我們使用Hibernate作為JPA的引擎，就可以這么來寫：

 
 
 
 
    
  
  
  
  
  1.  '1.0' encoding='UTF-8'?>   
    2. 
  
  
  
  
  2.  "http://java.sun.com/xml/ns/persistence"     
    3. 
  
  
  
  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    4. 
  
  
  
  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence    
    5. 
  
  
  
  
  5. http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"    
    6. 
  
  
  
  
  6.     version="1.0">   
    7. 
  
  
  
  
  7.      "course">     
    8. 
  
  
  
  
  8.               
    9. 
  
  
  
  
  9.              "hibernate.ejb.cfgfile" value="/hibernate.cfg.xml" />     
    10. 
  
  
  
  
  10.            
    11. 
  
  
  
  
  11.        
    12. 
  
  
  
  
  12.    
    13.

加載配置文件仍然使用Hibernate的配置文件，或者也可以將其中的property寫在persistence.xml中，那么因?yàn)樵谶@里JPA已經(jīng)可以獲取持久化單元了，在Hibernate的配置中就需要配置持久化對象的映射了，去掉mapping信息即可。有了配置信息，還需要實(shí)現(xiàn)類，我們重寫一個JPA的DAO實(shí)現(xiàn)，如下：

Java代碼

 
 
 
 
    
  
  
  
  
  1. package org.ourpioneer.course.dao;    
    2. 
  
  
  
  
  2. import java.util.List;    
    3. 
  
  
  
  
  3. import javax.persistence.EntityManager;    
    4. 
  
  
  
  
  4. import javax.persistence.EntityManagerFactory;    
    5. 
  
  
  
  
  5. import javax.persistence.EntityTransaction;    
    6. 
  
  
  
  
  6. import javax.persistence.Persistence;    
    7. 
  
  
  
  
  7. import javax.persistence.Query;    
    8. 
  
  
  
  
  8. import org.ourpioneer.course.bean.Course;    
    9. 
  
  
  
  
  9. public class CourseDAOImplJPA implements CourseDAO {    
    10. 
  
  
  
  
  10.     private EntityManagerFactory entityManagerFactory;    
    11. 
  
  
  
  
  11.     public CourseDAOImplJPA() {    
    12. 
  
  
  
  
  12.         entityManagerFactory = Persistence.createEntityManagerFactory("course");    
    13. 
  
  
  
  
  13.     }    
    14. 
  
  
  
  
  14.     public void delete(Course course) {    
    15. 
  
  
  
  
  15.         EntityManager manager = entityManagerFactory.createEntityManager();    
    16. 
  
  
  
  
  16.         EntityTransaction tx = manager.getTransaction();    
    17. 
  
  
  
  
  17.         try {    
    18. 
  
  
  
  
  18.             tx.begin();    
    19. 
  
  
  
  
  19.             manager.remove(manager.merge(course));    
    20. 
  
  
  
  
  20.             tx.commit();    
    21. 
  
  
  
  
  21.         } catch (RuntimeException e) {    
    22. 
  
  
  
  
  22.             tx.rollback();    
    23. 
  
  
  
  
  23.             throw e;    
    24. 
  
  
  
  
  24.         } finally {    
    25. 
  
  
  
  
  25.             manager.close();    
    26. 
  
  
  
  
  26.         }    
    27. 
  
  
  
  
  27.     }    
    28. 
  
  
  
  
  28.     public List  findAll() {      
    29. 
  
  
  
  
  29.         EntityManager manager = entityManagerFactory.createEntityManager();    
    30. 
  
  
  
  
  30.         try {    
    31. 
  
  
  
  
  31.             Query query = manager    
    32. 
  
  
  
  
  32.                     .createQuery("select course from Course course");    
    33. 
  
  
  
  
  33.             return query.getResultList();    
    34. 
  
  
  
  
  34.         } finally {    
    35. 
  
  
  
  
  35.             manager.close();    
    36. 
  
  
  
  
  36.         }    
    37. 
  
  
  
  
  37.     }    
    38. 
  
  
  
  
  38.     public Course findById(Long courseId) {    
    39. 
  
  
  
  
  39.         EntityManager manager = entityManagerFactory.createEntityManager();    
    40. 
  
  
  
  
  40.         try {    
    41. 
  
  
  
  
  41.             return manager.find(Course.class, courseId);    
    42. 
  
  
  
  
  42.         } finally {    
    43. 
  
  
  
  
  43.             manager.close();    
    44. 
  
  
  
  
  44.         }    
    45. 
  
  
  
  
  45.     }    
    46. 
  
  
  
  
  46.     public void save(Course course) {    
    47. 
  
  
  
  
  47.         EntityManager manager = entityManagerFactory.createEntityManager();    
    48. 
  
  
  
  
  48.         EntityTransaction tx = manager.getTransaction();    
    49. 
  
  
  
  
  49.         try {    
    50. 
  
  
  
  
  50.             tx.begin();    
    51. 
  
  
  
  
  51.             manager.persist(course);    
    52. 
  
  
  
  
  52.             tx.commit();    
    53. 
  
  
  
  
  53.         } catch (RuntimeException e) {    
    54. 
  
  
  
  
  54.             tx.rollback();    
    55. 
  
  
  
  
  55.             throw e;    
    56. 
  
  
  
  
  56.         } finally {    
    57. 
  
  
  
  
  57.             manager.close();    
    58. 
  
  
  
  
  58.         }    
    59. 
  
  
  
  
  59.     }    
    60. 
  
  
  
  
  60.     public void update(Course course) {    
    61. 
  
  
  
  
  61.         EntityManager manager = entityManagerFactory.createEntityManager();    
    62. 
  
  
  
  
  62.         EntityTransaction tx = manager.getTransaction();    
    63. 
  
  
  
  
  63.         try {    
    64. 
  
  
  
  
  64.             tx.begin();    
    65. 
  
  
  
  
  65.             manager.merge(course);    
    66. 
  
  
  
  
  66.             tx.commit();    
    67. 
  
  
  
  
  67.         } catch (RuntimeException e) {    
    68. 
  
  
  
  
  68.             tx.rollback();    
    69. 
  
  
  
  
  69.             throw e;    
    70. 
  
  
  
  
  70.         } finally {    
    71. 
  
  
  
  
  71.             manager.close();    
    72. 
  
  
  
  
  72.         }    
    73. 
  
  
  
  
  73.     }    
    74. 
  
  
  
  
  74. }   
    75.

這里特別要注意的是delete方法，首先調(diào)用merge方法，否則當(dāng)前對象是出于脫管態(tài)的，無法和Session進(jìn)行關(guān)聯(lián)，也就無法刪除該對象。不加merge方法時候會拋出異常，大家可以測試一下，因?yàn)榈讓舆€是Hibernate進(jìn)行的，Hibernate的持久化對象有三種狀態(tài)，那么就要注意狀態(tài)發(fā)生的變化。

#p#

現(xiàn)在我們來看如何在Spring中配置ORM資源工廠，也就是在Spring中使用ORM框架。仍然以Hibernate為例來說明，要引入spring-orm和spring-context模塊來做測試。首先我們可以修改一下DAO實(shí)現(xiàn)類的寫法，因?yàn)橛昧薙pring，就不用顯式來new對象了，那么對于Hibernate的SessionFactory，使用注入的方式來進(jìn)行配置，修改CourseDAOImpl類，如下設(shè)置：

 
 
 
 
    
  
  
  
  
  1. private SessionFactory sessionFactory;    
    2. 
  
  
  
  
  2. public void setSessionFactory(SessionFactory sessionFactory) {    
    3. 
  
  
  
  
  3.     this.sessionFactory = sessionFactory;    
    4. 
  
  
  
  
  4. }  
    5.

去掉構(gòu)造方法，為sessionFactory提供get方法即可。之后就是配置Spring了，很簡單，要配置courseDao和sessionFactory：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
    3. 
  
  
  
  
  3.        
    4. 
  
  
  
  
  4.  bean>   
    5. 
  
  
  
  
  5.    
    6. 
  
  
  
  
  6.      property>   
    7. 
  
  
  
  
  7.  bean> 
    8.

把Hibernate配置對象的映射文件加上，之后修改測試方法，從Spring的容器中獲取對象就可以了：

 
 
 
 
    
  
  
  
  
  1. ApplicationContext ctx = new ClassPathXmlApplicationContext(    
    2. 
  
  
  
  
  2.         "classpath:applicationContext.xml");    
    3. 
  
  
  
  
  3. CourseDAO courseDAO = (CourseDAO) ctx.getBean("courseDao");   
    4.

此時，我們還依賴Hibernate的配置文件，那么完全可以把Hibernate中的配置信息移入Spring之中，因?yàn)镾pring的ORM模塊完全支持Hibernate，可以如下進(jìn)行，我們使用C3P0作為連接池：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2.     scope="singleton" destroy-method="close">   
    3. 
  
  
  
  
  3.        
    4. 
  
  
  
  
  4.        
    5. 
  
  
  
  
  5.        
    6. 
  
  
  
  
  6.        
    7. 
  
  
  
  
  7.  bean>   
    8.

將數(shù)據(jù)庫的基本信息配置好后，數(shù)據(jù)源的配置就完成了。下面是配置Hibernate：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
    3. 
  
  
  
  
  3.        
    4. 
  
  
  
  
  4.     
  
  
  
  
  5.         value="classpath:org/ourpioneer/course/hbm/*.hbm.xml" />   
    6. 
  
  
  
  
  6.        
    7. 
  
  
  
  
  7.            
    8. 
  
  
  
  
  8.             org.hibernate.dialect.MySQLDialect prop>   
    9. 
  
  
  
  
  9.             true prop>   
    10. 
  
  
  
  
  10.             update prop>   
    11. 
  
  
  
  
  11.          props>   
    12. 
  
  
  
  
  12.      property>   
    13. 
  
  
  
  
  13.  bean>   
    14.

這里我們將實(shí)體映射一起配置進(jìn)來，使用了*通配符，并配置了基本的Hibernate屬性，比如方言，顯示sql語句和自動建表。剩下的就是DAO的配置了，它不用做什么修改，仍然注入sessionFactory即可，然后執(zhí)行測試：

從中可以看到啟動信息和Hibernate生成的SQL語句。除了使用Hibernate的實(shí)體映射文件外，我們還可以使用注解，之前已經(jīng)在Course持久化類中添加了注解，那么我們就來配置使用注解的方式，很簡單，只需修改Spring中的Hibernate SessionFactory配置即可，如下：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2. class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">   
    3. 
  
  
  
  
  3.        
    4. 
  
  
  
  
  4.        
    5. 
  
  
  
  
  5.            
    6. 
  
  
  
  
  6.             org.ourpioneer.course.bean.Course value>   
    7. 
  
  
  
  
  7.          list>   
    8. 
  
  
  
  
  8.      property>   
    9. 
  
  
  
  
  9.        
    10. 
  
  
  
  
  10.            
    11. 
  
  
  
  
  11.             org.hibernate.dialect.MySQLDialect prop>   
    12. 
  
  
  
  
  12.             true prop>   
    13. 
  
  
  
  
  13.             update prop>   
    14. 
  
  
  
  
  14.          props>   
    15. 
  
  
  
  
  15.      property>   
    16. 
  
  
  
  
  16.  bean>   
    17.

這樣就使用在持久化類中的注解信息而不需要單獨(dú)編寫HBM映射文件了，執(zhí)行測試，結(jié)果是一樣的。當(dāng)然，在Spring中，還可以使用JPA的EntityManager來進(jìn)行數(shù)據(jù)的持久化操作，那么又如何來進(jìn)行呢？和前面介紹的類似，首先在JPA的DAO實(shí)現(xiàn)類中修改EntityManager的配置方式，使用注入來進(jìn)行：

 
 
 
 
    
  
  
  
  
  1. private EntityManagerFactory entityManagerFactory;    
    2. 
  
  
  
  
  2. public void setEntityManagerFactory(    
    3. 
  
  
  
  
  3.         EntityManagerFactory entityManagerFactory) {    
    4. 
  
  
  
  
  4.     this.entityManagerFactory = entityManagerFactory;    
    5. 
  
  
  
  
  5. }   
    6.

同理，修改Spring的配置文件，配置EntityManagerFactory，如下：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
  2. class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">   
    3. 
  
  
  
  
  3.        
    4. 
  
  
  
  
  4.  bean>   
    5.

因?yàn)榕渲昧藀ersistenceUnitName，那么不要忘記了在META-INF目錄下的persistence.xml文件，其中是這么寫的：

 
 
 
 
    
  
  
  
  
  1.    
    2. 
  
  
  
  
  2.        
    3. 
  
  
  
  
  3.            
    4. 
  
  
  
  
  4.      properties>   
    5. 
  
  
  
  
  5.  persistence-unit>  
    6.
網(wǎng)頁標(biāo)題：Spring數(shù)據(jù)庫訪問之ORM
網(wǎng)站路徑：http://www.dlmjj.cn/article/cogsdch.html