随笔 - 251  文章 - 504  trackbacks - 0
<2006年12月>
日一二三四五六
262728293012
3456789
10111213141516
17181920212223
24252627282930
31123456

本博客系个人收集材料及学习记录之用，各类“大侠”勿扰！

留言簿(14)

随笔分类

收藏夹

My Favorite Web Sites

名Bloger

非著名Bloger

搜索

  •  

积分与排名

  • 积分 - 200151
  • 排名 - 285

最新评论

Learn Spring in spring(三)－转贴
三、spring中的hibernate开发

Bromon原创 请尊重版权

　　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.  * 创建日期 2005-3-17
  3.  */
  4. package net.bromon.spring.examer.pojo;
  6. /**
  7.  * @author Bromon
  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.  * 创建日期 2005-3-17
  3.  */
  4. package net.bromon.spring.examer.student;
  6. import net.bromon.spring.examer.pojo.Student;
  8. import org.springframework.orm.hibernate.HibernateTemplate;
  9. import org.springframework.orm.hibernate.LocalSessionFactoryBean;
  10. import org.springframework.orm.hibernate.support.HibernateDaoSupport;
  12. /**
  13.  * @author Bromon
  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>


　　所有的配置都完成了，下面做单元测试：

  1. /*
  2.  * 创建日期 2005-3-17
  3.  */
  4. package net.bromon.spring.examer.student.test;
  6. import java.io.FileInputStream;
  8. import org.springframework.beans.factory.xml.XmlBeanFactory;
  9. import org.springframework.context.ApplicationContext;
  10. import org.springframework.context.support.ClassPathXmlApplicationContext;
  12. import net.bromon.spring.examer.pojo.Student;
  13. import net.bromon.spring.examer.student.StudentManager;
  14. import junit.framework.TestCase;
  16. /**
  17.  * @author Bromon
  18.  */
  19. public class TestStudentManager extends TestCase {
  21.     public void testAdd() 
  22.     {
  23.         try
  24.         {
  25.             ApplicationContext context =new ClassPathXmlApplicationContext("springConfig.xml");
  26.             
  27.             Student s=new Student();
  28.             s.setName("bromon");
  29.             s.setPassword("123");
  30.             s.setGrade(3);
  31.             s.setSex(true);
  32.             
  33.             ((StudentManager)context.getBean("studentManager")).add(s);
  34.         }catch(Exception e)
  35.         {
  36.             e.printStackTrace();
  37.         }
  38.     }
  40. }

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

　　由于本文不讲解hibernate的使用，所以相关内容请查阅hibernate文档。

posted on 2006-12-14 11:31 matthew 阅读(242) 评论(0)  编辑  收藏 所属分类: JavaEE

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 matthew Powered by: 博客园 模板提供：沪江博客