SessionFactory、HibernateTemplate、HibernateDaoSupport之间的关系说明

在接触HibernateTemplate之前，我们知道，在对数据库进行CRUD操作之前，需要开启session、transaction等等。在hibernate学习过程中，我们知道了，得到session之前，需要先得到SessionFactory，进而从SessionFactory里面openSession(),或者getCurrentSession(),接着开启一transaction，然后进行对数据库的操作，在操作结束后，提交事务，关闭session。当然如果session是通过getCurrentSession()得到的话，不用我们手动关闭。还有，关于异常的处理，这就涉及到事务的回滚。我们发现，这样逻辑的代码我们需要反复使用，每次session的历程都是这样的。实例代码如下：

1. public class HibernateCoreAPITest {
2. private static SessionFactory sessionFactory;
3. @BeforeClass
4. public static void beforeClass() {
5. sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
6. }
7. @AfterClass
8. public static void afterClass() {
9. sessionFactory.close();
10. }
11. @Test
12. public void testTeacherSave() {
13. Teacher t = new Teacher();
14. t.setName("t1");
15. t.setTitle("middle");
16. t.setBirthDate(new Date());
17. //Session session = sessionFactory.openSession();
18. Session session = sessionFactory.getCurrentSession();
19. session.beginTransaction();
20. session.save(t);
21. session.getTransaction().commit();
22. }

HibernateTemplate

从上面测试用的代码(省略了异常处理和事务回滚)来看，如果在业务层某部分的功能模块比较多，那我们不得不老实重复关于session的代码。为避免这样的窘境，于是有了HibernateTemplate的出现。

给HibernateTemplate注入SessionFactory，我们就能获得利用SessionFactory来create sessionFactory，进而进行所有关于sessionFactory的功能操作。同时，由于HibernateTemplate本身关于sessionFactory的处理原理，我们不再需要手动编写关于sessionFactory、session、transaction等等代码。我们只需要编写关于业务逻辑相关的操作，其他的一并由HibernateTemplate完成。HibernateTemplate的这种设计模式我们称之为TemplateMethod，采用的方式叫callback或者钩子函数。这里的重点就是把SessionFactory注入到HibernateTemplate里面！！！

1. <span style="font-size:18px;">@Component("employeeDao")
2. public class EmployeeDaoImpl implements EmployeeDao {
3. private HibernateTemplate hibernateTemplate;
4. public HibernateTemplate getHibernateTemplate() {
5. return hibernateTemplate;
6. }
7. @Resource
8. public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
9. this.hibernateTemplate = hibernateTemplate;
10. }
11. @Override
12. public void save(Employee employee) {
13. hibernateTemplate().save(employee);
14. }</span>

上面的代码采用的是annotation方式，当然我们也可以使用xml方式，一样很简单。

HibernateDaoSupport

HibernateDaoSupport对于HibernateTemplate，就好比HibernateTemplate对于SessionFactory，两两的关系，大致雷同。只是这一次，HibernateDaoSupport是需要被继承的，而且不能像后者那样减少什么的代码量。就是把HibernateTemplate注入到HibernateDaoSupport里面，当然把SessionFactory注入到HibernateDaoTemplate里面一样可以。而起由于在HibernateDaoSupport里面set方法是final类型的，我们不能够重写该方法，所以就不能过通过annotation方式注入HibernateTemplate，只有采用xml方式。

1. <span style="font-size:18px;"><bean id="employeeDao" class="com.zzw.dao.impl.EmployeeDaoImpl">
2. <property name="hibernateTemplate" ref="hibernateTemplate"></property>
3. </bean></span>

1. <span style="font-size:18px;">public class EmployeeDaoImpl extends HibernateDaoSupport implements EmployeeDao {
2. @Override
3. public void save(Employee employee) {
4. this.getHibernateTemplate().save(employee);
5. }
6. @Override
7. public void delete(Employee employee) {
8. this.getHibernateTemplate().delete(employee);
9. }
10. @Override
11. public void update(Employee employee) {
12. this.getHibernateTemplate().update(employee);
13. }</span>

接着，我们来谈谈HibernateDaoSupport的拓展，当多个***Dao需要注入继承HibernateDaoSupport的时候，理所当然，我们得在applicationContext.xml里面给每个Dao注入hibernateTemplate或者sessionFactory。少量的好说，但是如果很多，比如几百个Dao(当然，这种情况我们很少遇到，我们假设这样)，这样，由于采用的是xml方式，我们配置起来一样显得麻烦。这个时候，我们可以这样解决，抽象一个顶层Dao类，这个类必须注入HibernateTemplate，其实这个注入了HibernateTemplate的顶层Dao类，他的功能类似于HibernateDaoSupport类，唯一的不同就是这个类里面的set方法是我们自己定义的，不是final类型的，所以我们采用注解annotation方式注入HibernateTemplate。然后，让那些***Dao继承这个顶层Dao类。这样在xml里面不用编写任何的注解配置，当然除了在HibernateTemplate里面注入sessionFactory。

注入HibernateTemplate的顶层Dao类：SuperDao.java

1. <span style="font-size:18px;">import javax.annotation.Resource;
2. import org.springframework.orm.hibernate3.HibernateTemplate;
3. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
4. import org.springframework.stereotype.Component;
5. @Component
6. public class SuperDAO {
7. private HibernateTemplate hibernateTemplate;
8. public HibernateTemplate getHibernateTemplate() {
9. return hibernateTemplate;
10. }
11. @Resource
12. public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
13. this.hibernateTemplate = hibernateTemplate;
14. }
15. }</span>

众多***Dao里面的一实例：UserDao.java

1. <span style="font-size:18px;">@Component("userDAO")
2. public class UserDAOImpl extends SuperDAO implements UserDAO {
3. public void save(User user) {
4. this.getHibernateTemplate().save(user);
5. }
6. }</span>

从上面的代码中，我们发现整个过程我们并没有使用HibernateDaoSupport这个抽象类，而是使用一个它的替代类：由我们自己定义的。如果非得使用HibernateDaoSupport类的话，也可以，就是讲顶层Dao类SuperDao改为：

1. <span style="font-size:18px;">@Component
2. public class SuperDAO extends HibernateDaoSupport {
3. @Resource(name="hibernateTemplate")
4. public void setSuperHibernateTemplate(HibernateTemplate hibernateTemplate) {
5. super.setHibernateTemplate(hibernateTemplate);
6. }
7. }
8. </span>

注意：spring容器在对子类进行初始化的时候，首先会将其父类进行初始化，而如果两者的注入方式不一致，比如一个是xml方式，一个是annotation方式的话，很容易出错，所以，最好使用同种注入方式！

最后，温馨提示：建议使用HibernateTemplate的annotation注入方式，即第二种哦，亲！