Spring 对hibernate的强大支持

首先需要配置数据源，通常我们有两种方式获得Connection，一是自己编写代码获得连接，二是从JNDI环境中得到DataSource，然后产生 一个Connection。无论怎样，既然是spring下面的对象，就应该注册到配置文件中。假设我们需要一个连接mysql下面一个叫做examer 的数据库，手动方式的配置是：

   1.   < bean  id ="dataSource"  class ="org.apache.commons.dbcp.BasicDataSource"
destroy-method ="close" >
   2. 　　 < property  name ="driverClassName" >
   3. 　　　　 < value > com.mysql.jdbc.Driver </ value >
   4. 　　 </ property >
   5. 　　 < property  name ="url" >
   6. 　　　　 < value > jdbc:mysql://localhost/examer </ value >
   7. 　　 </ property >
   8. 　　 < property  name ="username" >
   9. 　　　　 < value > root </ value >
  10. 　　 </ property >
  11. 　　 < property  name ="password" >
  12. 　　　　 < value ></ value >
  13. 　　 </ property >
  14.  </ bean >

很好读是不是？假如我们使用JNDI数据源，那么dataSource的声明就应该是：

   1.   < bean  id ="dataSource"  class ="org.springframework.jndi.JndiObjectFactoryBean" >
   2. 　　 < property  name ="jndiName" >
   3. 　　　　 < value > java:compenvjdbcspringExamer </ value >
   4. 　　 </ property >
   5.  </ bean >

你需要在JNDI环境中绑定一个名为jdbc/springExamer的东西，这段代码才有实际意义。另外需要提醒的是，所有的bean声明，它的id必须是唯一的。

　　在本系统中，数据库操作是被hibernate封装起来的，所以dataSource是不需要注入到具体的逻辑类中，它只会被注给hibernate的sessionFactory。

　 　按照常规思路，我们需要在spring中注册hibernate的sessionFactory，它应该是我们自己编写的一个类，获得 dataSource，返回sessionFactory，其他的逻辑类通过这个sessionFactory获得session进行数据库操作。

　 　 但是我们有另外一种选择，spring直接提供了对sessionFactory的封装，你只需要注册一个 spring自己的类，给它提供必须的属性，它会返回一个 org.springframework.orm.hibernate.HibernateTemplate，这个类封装了add、del等操作，它的封 装程度相当高，通过它来编写hibernate应用非常简单。但是问题出来了，我们该如何选择？

　 　表面上看，使用spring自己的库无疑更加简单，但是请注意，spring是一个轻量级的框架，所谓轻量级，一个重要特征就是无侵入性，也就是你使用 这套框架，不会被它绑定，被spring管理的类，应该不需要使用它的接口和抽象类，这样你的系统不会对spring产生依赖。但是如果你使用了 spring封装的方式去操作hibernate，就必须继承 org.springframework.orm.hibernate.support.HibernateDaoSupport类，这导致了绑定。所以 做这样的选择是有点痛苦的，如果有一天spring框架不存在了，你的代码怎么升级维护？具体问题只能具体分析，在我们的应用中，完全使用了spring 封装的HibernateTemplate，它太好用了，所以容易上瘾 。
　 　 假设我们有一张student表，结构很简单：

    1 .       id　　　　　　    自动增长
    2 . 　　name　　　　　varchar( 40 )
    3 . 　　password　　varchar( 32 )
    4 . 　　grade    　　　 int( 4 )　　　　　　      年级
    5 . 　　sex　　　　　    Boolean　　　　　　性别(true为男，false为女)

设计一个Student类来映射这张表：

    1 .   /**/ /*
   2.  * 创建日期 2007-10-11
   3.  */
    4 .  package  net.bromon.spring.examer.pojo;
    5 .  
    6 .  /** */ /**
   7.  * @author xxx
   8.  */
    9 .  public   class  Student 
   10 .  ... {
  11.     private int id;
  12.     private String name;
  13.     private String password;
  14.     private int grade;//年级
  15.     private boolean sex;
  16.     
  17.     getset方法……….
  18. }

编写Student.hbm.xml，让hibernate知道如何去关联student表和Student类，该文件和Student.java在同一目录：

   1.   < hibernate-mapping >
   2. 　　 < class  name ="net.bromon.spring.examer.pojo.Student"  table ="student" >
   3. 　　　　 < id  name ="id"  column ="id" >
   4. 　　　　　　 < generator  class ="identity" />
   5. 　　　　 </ id >
   6.         
   7. 　　　　 < property  name ="name"  column ="name"   />
   8. 　　　　 < property  name ="password"  column ="password"   />
   9. 　　　　 < property  name ="grade"  column ="grade"   />
  10. 　　　　 < property  name ="sex"  column ="sex"   />
  11. 　　 </ class >
  12.  </ hibernate-mapping >

然后我们可以在spring中配置sessionFactory：

   1.   < bean  id ="sessionFactory" 　class ="org.springframework.orm.hibernate.LocalSessionFactoryBean" >
   2. 　　 < property  name ="dataSource" >
   3. 　　　　 < ref  bean ="dataSource" />
   4. 　　 </ property >
   5.         
   6. 　　 < property  name ="hibernateProperties" >
   7. 　　　　 < props >
   8. 　　　　　　 < prop  key ="hibernate.dialect" > net.sf.hibernate.dialect.MySQLDialect </ prop >
   9. 　　　　 </ props >
  10. 　　 </ property >
  11.         
  12. 　　 < property  name ="mappingDirectoryLocations" >
  13. 　　　　 < list >
  14. 　　　　　　 < value > classpath:/netbromonspringexamerpojo </ value >
  15. 　　　　 </ list >
  16. 　　 </ property >
  17.  </ bean >

其中引用了我们之前注册过的dataSource，mappingDirectoryLocations属性指明了.hbm.xml文件在哪里路径，该文件夹下面的.hbm.xml文件会被全部加载。

　　 一切都准备就绪，现在我们要加入一个StudentManager类，来进行增删查改的操作：

    1 .   /**/ /*
   2.  * 创建日期 2007-10-11
   3.  */
    4 .  package  net.bromon.spring.examer.student;
    5 .  
    6 .  import  net.bromon.spring.examer.pojo.Student;
    7 .  
    8 .  import  org.springframework.orm.hibernate.HibernateTemplate;
    9 .  import  org.springframework.orm.hibernate.LocalSessionFactoryBean;
   10 .  import  org.springframework.orm.hibernate.support.HibernateDaoSupport;
   11 .  
   12 .  /** */ /**
  13.  * @author XXX
  14.  */
   15 .  public   class  StudentManager  extends  HibernateDaoSupport
   16 .  ... {
  17.     private LocalSessionFactoryBean sessionFactory;
  18.     private HibernateTemplate ht;
  19.     public StudentManager()
  20.     ...{
  21.         this.ht=super.getHibernateTemplate();
  22.     }
  23.     
  24.     public void add(Student s)
  25.     ...{   
  26.         ht.save(s);//插入一条数据只需要这一行代码
  27.     }
  28. }

该类只演示了如何增加一个Student，HibernateTemplate还封装了很多有用的方法，请查阅spring文档。 StudentManager中的sessionFactory是由spring注入的，但是StudentManager并没有对 sessionFactory做任何的处理，这是因为所有的处理都被HibernateDaoSupport.getHibernateTemplate ()封装。整个StudentManager中也看不到任何的异常处理，他们也都被基类封装了。

　　 最后一个步骤就是在spring中注册StudentManger，然后向它注入sessionFactory：

   1.   < bean  id ="studentManager"  class ="net.bromon.spring.examer.student.StudentManager" >
   2. 　　 < property  name ="sessionFactory" >
   3. 　　　　 < ref  bean ="sessionFactory" />
   4. 　　 </ property >
   5.  </ bean >

    Spring已经将hibernate的操作简化到了非常高的程度，最关键的是整个开发可以由设计来驱动，如果一个团队对spring有足够的熟悉，那么 完全可以由设计师规划所有的类，整理清楚类之间的关系，写成配置文件，然后编写hibernate映射文件，将数据表与pojo关联，成员就可以完全在设 计方案内工作，利用spring封装好的hibernate模版，开发起来速度非常快，调试也很容易。它能够解决如何在团队内贯彻设计方案的问题。