Spring对HibernateSession的管理之封装SessionFactory

　　我刚刚在上一篇博文中将Spring对HibernateSession的管理做了一些皮毛的分析，主要围绕着Spring是怎样平衡Session的关闭时间。即在是否需要延时Session有效期以保证页面的调用。

　　

　　那么现在我们来看看Spring是怎样管理Session的生产者：SessionFactory的。

　　首先，我们在学习Spring的时候一般都会涉及到将SSH框架整合起来使用了，还记得我们怎样配置Spring吗？

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    ……
    <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="……"></property>
        <property name="password" value="……"></property>
    </bean>
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource"></ref>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.Oracle10gDialect
                </prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <property name="mappingResources">
            <list><value>orm/Users.hbm.xml</value></list>
        </property>
    </bean>
    
    <bean id="userDao" class="……">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="userServer" class="……">
        <property name="userdao" ref="userDao"/>
    </bean>
    <bean id="userAction" class="……">
        <property name="userserver" ref="userServer"/>
    </bean>
    ……
</beans>

　　在不涉及到声明性事务和自动装配时我们一般按上述配置（上述配置为MyEclipse环境下的自动生成）。

　　不知道大家有没有注意到：我们的Dao需要的SessionFactory是org.hibernate.SessionFactory（我们的Dao为了代码重用，继承自HibernateDaoSupport），而上面的装配却没有给一个SessionFactory或其子类。

　　

　　org.springframework.orm.hibernate3.support.HibernateDaoSupport源代码（省略了注释）：

package org.springframework.orm.hibernate3.support;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.dao.support.DaoSupport;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
public abstract class HibernateDaoSupport extends DaoSupport {

    private HibernateTemplate hibernateTemplate;

    public final void setSessionFactory(SessionFactory sessionFactory) {
        if (this.hibernateTemplate == null || sessionFactory != this.hibernateTemplate.getSessionFactory()) {
            this.hibernateTemplate = createHibernateTemplate(sessionFactory);
        }
    }

    protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
        return new HibernateTemplate(sessionFactory);
    }

    public final SessionFactory getSessionFactory() {
        return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null);
    }

    public final void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    public final HibernateTemplate getHibernateTemplate() {
      return this.hibernateTemplate;
    }

    @Override
    protected final void checkDaoConfig() {
        if (this.hibernateTemplate == null) {
            throw new IllegalArgumentException("'sessionFactory' or 'hibernateTemplate' is required");
        }
    }


    protected final Session getSession()
        throws DataAccessResourceFailureException, IllegalStateException {

        return getSession(this.hibernateTemplate.isAllowCreate());
    }


    protected final Session getSession(boolean allowCreate)
        throws DataAccessResourceFailureException, IllegalStateException {

        return (!allowCreate ?
            SessionFactoryUtils.getSession(getSessionFactory(), false) :
                SessionFactoryUtils.getSession(
                        getSessionFactory(),
                        this.hibernateTemplate.getEntityInterceptor(),
                        this.hibernateTemplate.getJdbcExceptionTranslator()));
    }

    protected final DataAccessException convertHibernateAccessException(HibernateException ex) {
        return this.hibernateTemplate.convertHibernateAccessException(ex);
    }

    protected final void releaseSession(Session session) {
        SessionFactoryUtils.releaseSession(session, getSessionFactory());
    }

}

　　从源代码可以看到，属性所需类型确实为org.hibernate.SessionFactory（上述代码16行处可看出）。

　　我是偶然发现这一点的，在后来，我顺着LocalSessionFactoryBean的父类或接口向上追溯：

　　　　LocalSessionFactoryBean extends AbstractSessionFactoryBean implements BeanClassLoaderAware

　　　　AbstractSessionFactoryBean extends HibernateExceptionTranslator
  implements FactoryBean<SessionFactory>, InitializingBean, DisposableBean

　　在经过分析后，我把重点放在了FactoryBean<SessionFactory>这个接口上，它实际上是一个泛型接口，原型如下：

　　org.springframework.beans.factory.FactoryBean源代码（省略了注释）：

package org.springframework.beans.factory;

public interface FactoryBean<T> {

    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();

}

　　看到这里，我一度认为自己掌握了这种方式，于是我开始着手进行实验（以下是我进行实验的项目，只是一个添加了Spring支持的Java Project。注意添加Spring的aop支持）：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    // main方法，从Spring容器中拿到对象
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println(ac.getBean("tt"));
    }
}
// 用作实体类，可以看做org.hibernate.SessionFactory
class E {

}
// 用做泛型接口，可以看作org.springframework.beans.factory.FactoryBean
interface MyFactoryBean<T> {

}
// 用做真正构造得到的类，可以看作org.springframework.orm.hibernate3.LocalSessionFactoryBean
class T implements MyFactoryBean<E> {
    
}
// 用作使用实体作为属性的类，可以看作org.springframework.orm.hibernate3.support.HibernateDaoSupport
class M{
    private E e;
    public void setE(E e){
        this.e = e;
    }
}

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- 我写得不是很语义化，大家重在理解 -->
    
    <!-- 简单理解，此处的dd是实现了泛型接口的类 class T implements MyFactoryBean<E> 而实际上，它和E无关 -->
    <!-- 此处的M需要一个E来作为属性，它的set方法需要一个E类型的参数，但我们给它一个T -->
    <bean id="dd" class="T"></bean>
    <bean id="tt" class="M">
        <property name="e" ref="dd" />
    </bean>
</beans>

　　这样就可以吗？事实证明：NO！

　　ps:也对，这样都行的话，国足能进世界杯（进过吗？不清楚）。

　　

　　得到一个异常（大家翻译一下就明了）：java.lang.IllegalStateException: Cannot convert value of type [T] to required type [E] for property 'e': no matching editors or conversion strategy found。

　　看到这个异常，我忽然想到：难道是因为没有类似org.springframework.beans.factory.FactoryBean中的getObject方法？

　　于是，我连夜进行测试，在接口和实现中添加方法，改进后如下

interface MyFactoryBean<T> {
    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();
}
class T implements MyFactoryBean<E> {

    @Override
    public E getObject() throws Exception {
        return new E();
    }

    @Override
    public Class<?> getObjectType() {
        return E.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
    
}

　　结果证明：纯属坑爹，这不是换汤不换药吗？

　　最后，我使用了Spring自带的FactoryBean：

import org.springframework.beans.factory.FactoryBean;
//……
class T implements FactoryBean<E> {

    @Override
    public E getObject() throws Exception {
        return new E();
    }

    @Override
    public Class<?> getObjectType() {
        return E.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
    
}
//……

　　这才成功了！

　　由此可见，Spring用了某种转换来搞定这个事情，其中设计到多种设计模式，下次再深入研究。

　

 

 欢迎您移步我们的交流群，无聊的时候大家一起打发时间：

 或者通过QQ与我联系：

 （最后编辑时间2012-10-11 17:32:29）