Hibernate 源码分析

1、Hibernate之生成SessionFactory源码追踪

Hibernate的所有session都是由sessionFactory来生成的，那么，sessionFactory是怎么得来的呢？它与我们配置的xxx.cfg.xml文件以及xxx.hbm.xml文件之间又有着怎么样的联系呢？

先看一小段生成sessionFactory的代码：

code_1:

public class HibernateTest {
    @Test
    public void test() {        
        System.out.println("test...");        
        
        //1. 创建一个 SessionFactory 对象
        SessionFactory sessionFactory = null;       
        
        //1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和 对象关系映射信息
        Configuration configuration = new Configuration().configure();
        
        //4.0 之前这样创建
        //sessionFactory = configuration.buildSessionFactory();
        
        //2). 创建一个 ServiceRegistry 对象: hibernate 4.x 新添加的对象
        //hibernate 的任何配置和服务都需要在该对象中注册后才能有效.
        ServiceRegistry serviceRegistry = 
            new ServiceRegistryBuilder().applySettings(configuration.getProperties())
            .buildServiceRegistry();
        
        //3). 利用serviceRegistry来创建sessionFactory实例
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);        
        
        //2. 创建一个 Session 对象
        Session session = sessionFactory.openSession();
        
        //3. 开启事务
        Transaction transaction = session.beginTransaction();
        
        //4. 执行保存操作
        News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));
        session.save(news);
        
        //5. 提交事务 
        transaction.commit();
        
        //6. 关闭 Session
        session.close();
        
        //7. 关闭 SessionFactory 对象
        sessionFactory.close();
    }   
}

从上面的代码很清晰的可以看见，这一切的源头都在 Configuration configuration = new Configuration().configure() 这条语句上：创建ServiceRegistry 需要用到configuration，生成sessionFactory同样需要用到configuration。

Configuration的生成过程

从源代码中可以看到，Configuration的configure()方法共有5中重载方式：

code_2:

public Configuration configure();        //无参
public Configuration configure(String resource)
public Configuration configure(URL url)
public Configuration configure(File configFile)
public Configuration configure(org.w3c.dom.Document document)

现在从无参的configure()方法开始分析，它代表了一种默认的行为，默认读取类路径下的hibernate.cfg.xml文件作为hibernate的配置文件：

code_3:

public Configuration configure() throws HibernateException {
    configure( "/hibernate.cfg.xml" );    //默认读取classpath路径下的hibernate.cfg.xml文件
    return this;
}

继续追踪configure( “/hibernate.cfg.xml” )方法：

code_4:

1 public Configuration configure(String resource) throws HibernateException {
2     InputStream stream = getConfigurationInputStream( resource );    //通过传入的资源路径获取一个输入流
3     return doConfigure( stream, resource );    //这个方法会完成解析的第一步：将输入流转换成Document对象
4 }

继续追踪 return doConfigure( stream, resource ) 语句，可以发现底层会通过SAX解析工具将输入流转换成Document对象。然后调用然后调用doConfigure(Document doc)来继续解析这个文档：

code_5:

 1 protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {
 2         
 3     ErrorLogger errorLogger = new ErrorLogger( resourceName );  //将输入流转换成Document对象
 5     Document document = xmlHelper.createSAXReader( errorLogger,  entityResolver )
 6                 .read( new InputSource( stream ) );
 7         //具体解析document树，并将结果以键值对的形式存放到properties中
 8     doConfigure( document );
 9         
10     return this;
11 }

doConfigure(Document doc)是实际解析文档的方法，前面configure()的5种重载方法最后都要调用这个方法来完成实际的解析。我们看看它的解析思路：

code_6:

 1 protected Configuration doConfigure(Document doc) throws HibernateException {
 2     Element sfNode = doc.getRootElement().element( "session-factory" );
 3     String name = sfNode.attributeValue( "name" );
 4     if ( name != null ) {    //session-factory根节点是可以有name属性值的
 5         properties.setProperty( Environment.SESSION_FACTORY_NAME, name );
 6     }
 7     //遍历文档中所有的property节点，读取器name属性值以及节点的文本，
 8     //以name-value的形式放入到properties中
 9     addProperties( sfNode );    
10     //解析除了property之外的节点：mapping、class-cache、collection-cache
11     parseSessionFactory( sfNode, name );
12 
13     Element secNode = doc.getRootElement().element( "security" );
14     if ( secNode != null ) {
15         parseSecurity( secNode );
16     }
17 
18     LOG.configuredSessionFactory( name );
19     LOG.debugf( "Properties: %s", properties );
20 
21     return this;
22 }

doConfigure(Document doc)方法中对Document的解析主要分为两个步骤进行：

①解析xxx.cfg.xml配置文档中所有的property节点；

②解析xxx.cfg.xml配置文档中除了property节点之外的其它5种节点。

先来看看第

①步，它在addProperties(…)方法中完成（code_6代码段的第9行）思路很清晰，用一个迭代器来遍历文档中所有的property节点，并将name-value存放到Configuration的properties属性中：

code_7:

 1 private void addProperties(Element parent) {
 2     //指定，只会遍历property节点
 3     Iterator itr = parent.elementIterator( "property" );
 4     while ( itr.hasNext() ) {//循环遍历
 5         Element node = (Element) itr.next();
 6         //读取节点的name属性值
 7         String name = node.attributeValue( "name" );
 8         //读取节点的文本值
 9         String value = node.getText().trim();
10         LOG.debugf( "%s=%s", name, value );
11         //将name-value值存放如properties中
12         properties.setProperty( name, value );
13         //待研究...
14         if ( !name.startsWith( "hibernate" ) ) {
15             properties.setProperty( "hibernate." + name, value );
16         }
17     }
18         Environment.verifyProperties( properties );
19 }

再来看看第②步，它在parseSessionFactory( …)方法中进行（code_6代码段的第10行），它主要解析3类标签：mapping、class-cache、collection-cache：

code_8:

 1 private void parseSessionFactory(Element sfNode, String name) {
 2     Iterator elements = sfNode.elementIterator();
 3     while ( elements.hasNext() ) {
 4         Element subelement = (Element) elements.next();
 5         String subelementName = subelement.getName();
 6         //解析mapping节点，mapping可以指定hibernate的映射文件位置
 7         if ( "mapping".equals( subelementName ) ) {
 8             //具体解析mapping节点
 9             parseMappingElement( subelement, name );
10         }
11         //下面两个是和hibernate的二级缓存相关的配置，不做深入探讨
12         else if ( "class-cache".equals( subelementName ) ) {
13             String className = subelement.attributeValue( "class" );
14             Attribute regionNode = subelement.attribute( "region" );
15             final String region = ( regionNode == null ) ? className : regionNode.getValue();
16             boolean includeLazy = !"non-lazy".equals( subelement.attributeValue( "include" ) );
17             setCacheConcurrencyStrategy( className, subelement.attributeValue( "usage" ), region, includeLazy );
18         }
19         else if ( "collection-cache".equals( subelementName ) ) {
20             String role = subelement.attributeValue( "collection" );
21             Attribute regionNode = subelement.attribute( "region" );
22             final String region = ( regionNode == null ) ? role : regionNode.getValue();
23             setCollectionCacheConcurrencyStrategy( role, subelement.attributeValue( "usage" ), region );
24         }
25     }
26 }

后面两个标签class-cache和collection-cache是和hibernate的二级缓存相关，不作深入探讨。主要看看解析mapping的方法：

code_9:

 1 private void parseMappingElement(Element mappingElement, String name) {
 2     // 从源代码可以看出，mapping节点支持的属性值有5个
 3     final Attribute resourceAttribute = mappingElement.attribute( "resource" );
 4     final Attribute fileAttribute = mappingElement.attribute( "file" );
 5     final Attribute jarAttribute = mappingElement.attribute( "jar" );
 6     final Attribute packageAttribute = mappingElement.attribute( "package" );
 7     final Attribute classAttribute = mappingElement.attribute( "class" );
 8 
 9     if ( resourceAttribute != null ) {
10         final String resourceName = resourceAttribute.getValue();
11         LOG.debugf( "Session-factory config [%s] named resource [%s] for mapping", name, resourceName );
12         //将hibernate的映射文件作进一步的解析
13         addResource( resourceName );
14     }
15     else if ( fileAttribute != null ) {
16         final String fileName = fileAttribute.getValue();
17         LOG.debugf( "Session-factory config [%s] named file [%s] for mapping", name, fileName );
18         addFile( fileName );
19     }
20     else if ( jarAttribute != null ) {
21         final String jarFileName = jarAttribute.getValue();
22         LOG.debugf( "Session-factory config [%s] named jar file [%s] for mapping", name, jarFileName );
23         addJar( new File( jarFileName ) );
24     }
25     else if ( packageAttribute != null ) {
26         final String packageName = packageAttribute.getValue();
27         LOG.debugf( "Session-factory config [%s] named package [%s] for mapping", name, packageName );
28         addPackage( packageName );
29     }
30     else if ( classAttribute != null ) {
31         final String className = classAttribute.getValue();
32         LOG.debugf( "Session-factory config [%s] named class [%s] for mapping", name, className );
33         try {
34             addAnnotatedClass( ReflectHelper.classForName( className ) );
35         }
36         catch ( Exception e ) {
37             throw new MappingException(
38                     "Unable to load class [ " + className 
    					+ "] declared in Hibernate configuration <mapping/> entry",e);
41         }
42     }
43     else {
44         throw new MappingException( "<mapping> element in configuration specifies no known attributes" );
45     }
46 }

addResource( resourceName )是如何解析的呢？那么它是如何工作的呢？这里不再一步一步追踪源代码，因为嵌套太深，直接给出一个感性的认识即可:
在Configuration中定义了一个名为MetadataSourceQueue的内部内，同时Configuration中还有一个该队列的属性值：metadataSourceQueue。
addResource( resourceName )方法嵌套到最后会调用metadataSourceQueue.add(…)方法来将映射的元数据存储到metadataSourceQueue队列中。要使用的时候，从该队列中取就可以了。
metadataSourceQueue的底层存储是一个Map类型…

到现在为止，Configuration对象就得到了，总结一下，其重要的几个点：
1、configure()方法默认读取/hibernate.cfg.xml作为hibernate的配置文件。当然，configure()方法还有其它重载形式可用。
2、doConfigure(Document document)方法会调用两个重要的方法：addProperties( sfNode )和parseSessionFactory( sfNode, name );
3、addProperties( sfNode )方法会解析配置文件中的property节点，并将解析到的name-value放入到properties中
4、parseSessionFactory( sfNode, name )方法会解析配置文件中除了property节点外的其它3个类型的节点（4.2版本）：mapping、class-cache和collection-cache
5、mapping配置是和映射相关的，class-cache和collection-cache是与二级缓存相关的。
6、mapping解析的结果会存放到metadataSourceQueue对象中。
7、所以，整个过程得到Configuration中两个重要的属性值：properties和metadataSourceQueue。

2、Spring的LocalSessionFactoryBean创建过程源码分析

spring的LocalSessionFactoryBean生成过程与hibernate的SessionFactory生成过程是高度吻合的。

为了后面源码分析，首先讲解一个接口，一个类的功能：
①、接口InitializingBean
接口的功能：这个接口专门为bean设计的，它只有一个方法。我们知道所有的bean都是由beanFactory来生成的，如果一个bean实现了该接口，在beanFactory为该bean装配好了所有的属性以后，在返回实际bean之前还会调用一次该接口的afterPropertiesSet(…)方法。其设计目的是为了实现个性化，或者是为了检查bean属性值的完整性等。

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

②、类LocalSessionFactoryBuilder

显然，LocalSessionFactoryBuilder继承自org.hibernate.cfg.Configuration，那么Configuration拥有的属性，LocalSessionFactoryBuilder也具有

public class LocalSessionFactoryBuilder extends Configuration{
    //...
}

从LocalSessionFactoryBean源码中分析出其于hibernate的sessionFactory和configuration之间的关系：

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

//②、类LocalSessionFactoryBuilder
//显然，LocalSessionFactoryBuilder继承自org.hibernate.cfg.Configuration，那么Configuration拥有的属性，LocalSessionFactoryBuilder也具有
public class LocalSessionFactoryBuilder extends Configuration{
    //...
}

//现在主要分析LocalSessionFactoryBean
//1、看一下几个非常重要的属性值定义
public class LocalSessionFactoryBean extends... implements InitializingBean, ...{
    //数据源
    private DataSource dataSource;
    //hibernate的配置文件Xxx.cfg.xml所在的
    //位置多个可以用","隔开
    private Resource[] configLocations;
    private String[] mappingResources;
    //hibernate的映射文件位置
    private Resource[] mappingLocations;
    //hibernate的properties属性，存放了配置
    //文件中解析property标签的结果
    private Properties hibernateProperties;
    //hibernate的configuration属性
    private Configuration configuration;
    //这个sessionfactory是hibernate的sessionFactory
    private SessionFactory sessionFactory;
    
    //省略其它的属性以及setter方法...
    
    //注意这个set方法，说明当只有一个配置文件
    //的时候可以使用configLocation属性来配置，
    //最终也会被转换成configLocations
    public void setConfigLocation(Resource configLocation) {
        this.configLocations = new Resource[] {configLocation};
    }
    
    @Override
    public void afterPropertiesSet() throws IOException {
        LocalSessionFactoryBuilder sfb = new LocalSessionFactoryBuilder(this.dataSource, this.resourcePatternResolver);

        if (this.configLocations != null) {
            for (Resource resource : this.configLocations) {
                //sfb.configure(...)实际上也就是调用其父类
                //org.hibernate.cfg.Configuration的configure(...)方法
                //这里完成xxx.cfg.xml文件中property节点
                //的解析，得到一个properties
                sfb.configure(resource.getURL());
            }
        }

        //mappingResources和mappingLocations效果是一样的，
        //都会将资源转换成输入流，并调用sfb.addInputStream(...)方法
        //sfb.addInputStream(...)最终会完成xxx.cfg.xml文件的
        //非property节点解析（主要有3类：mapping、class-cache和collection-cache）
        //将解析结果放入到metadataSourceQueue中
        if (this.mappingResources != null) {
            for (String mapping : this.mappingResources) {
                Resource mr = new ClassPathResource(mapping.trim(), this.resourcePatternResolver.getClassLoader());
                sfb.addInputStream(mr.getInputStream());
            }
        }
        if (this.mappingLocations != null) {
            for (Resource resource : this.mappingLocations) {
                sfb.addInputStream(resource.getInputStream());
            }
        }

        //sfb.addProperties(...)方法会调用properties.putAll( extraProperties )方法
        //说明我们可以配置一个properties对象来达到配置xxx.cfg.xml相同的效果！！
        //两方面的配置最终都会放入到properties对象中
        if (this.hibernateProperties != null) {
            sfb.addProperties(this.hibernateProperties);
        }
        
        //省略若干其它方法...

        // 将sfb向上转型，LocalSessionFactoryBean中的configuration属性实际上
        // 就是org.hibernate.cfg.Configuration
        this.configuration = sfb;
        //在得到configuration以后，通过它来创建一个sessionFactory，
        //并赋值给sessionFactory属性（LocalSessionFactoryBean的属性）
        //在底层会调用return super.buildSessionFactory()来的到一个
        //sessionFactory，由于其父类是org.hibernate.cfg.Configuration
        //所以，相当于调用了configuration.buildSessionFactory()来生成
        //sessionFactory，这是hibernate4.0版本之前的做法，新版本已经
        //被buildSessionFactory(ServiceRegistry)所取代。 
        this.sessionFactory = buildSessionFactory(sfb);
    }
}

总结:

spring的LocalSessionFactoryBean实际完成的工作有：
1、通过解析bean中的configLocation和mappingLocations等属性，得到一个hibernate的原生态的org.hibernate.cfg.Configuration属性
2、通过org.hibernate.cfg.Configuration生成一个hibernate原生态的org.hibernate.SessionFactory属性
3、可以在外部配置一个Properties对象，并将其配置为properties属性，可以达到与xxx.cfg.xml相同的配置效果

3、Spring整合Hibernate

我们可以得到这样一个结论，spring的LocalSessionFactoryBean具体是调用Hibernate的Configuration中configure(…)方法来读取并解析xxx.cfg.xml文件的，同样也会得到一个原生态的org.hibernate.cfg.Configuration 和 org.hibernate.SessionFactory属性。

所以，我们可以看见LocalSessionFactoryBean中保存有hibernate的configuration、sessionFactory、properties 以及 metadataSourceQueue。

从前面两节分析中我们知道，LocalSessionFactoryBean会读取并解析xxx.cfg.xml和xxx.hbm.xml文件，所以在配置LocalSessionFactoryBean的时候需要明确指定这两个文件的位置。当然，连接数据库的dataSource也要配置在spring的bean中：

下面是一个spring整合hibernate的实例：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:aop="http://www.springframework.org/schema/aop"
 5     xmlns:context="http://www.springframework.org/schema/context"
 6     xmlns:tx="http://www.springframework.org/schema/tx"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 8         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
 9         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
10         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
11 
12     <!-- 配置自动扫描的包 -->
13     <!-- 实体和dao -->
14     <context:component-scan base-package="comentity,com.dao.impl"></context:component-scan>
15     <!-- service -->
16     <context:component-scan base-package="com.service.impl"></context:component-scan>
17 
18     <!-- 导入数据库资源文件 -->
19     <context:property-placeholder location="classpath:db.properties"/>
20     
21     <!-- 配置c3p0数据源 -->
22     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
23         <property name="user" value="${jdbc.user}"></property>
24         <property name="password" value="${jdbc.password}"></property>
25         <property name="driverClass" value="${jdbc.driverClass}"></property>
26         <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
27         
28         <property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>
29         <property name="minPoolSize" value="${jdbc.minPoolSize}"></property>
30         <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
31         <property name="acquireIncrement" value="${jdbc.acquireIncrement}"></property>
32     </bean>
33     
34     <!-- 配置sessionFacory -->
35     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
36         <property name="dataSource" ref="dataSource"></property>
37         <!-- 如果有多个配置文件，可以使用属性configLocations来配置，多个配置文件之间用逗号“,”来分割，
38             如：classpath:hibernate.cfg.xml,classpath:extension.cfg.xml -->
39         <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
40         <!-- ORM映射关系配置文件 -->
41         <property name="mappingLocations" value="classpath:com/gzpp123/web/entity/*.hbm.xml"></property>
42     </bean>
43     
44     <!-- 配置spring的声明式事物 -->
45     <!-- 1、配置hibernate的事物管理器 -->
46     <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
47         <property name="sessionFactory" ref="sessionFactory"></property>
48     </bean>
49     
50     <!-- 2、配置事物属性 -->
51     <tx:advice id="txAdvice" transaction-manager="transactionManager">
52         <tx:attributes>
53             <tx:method name="get*" read-only="true"/>
54             <tx:method name="*"/>
55         </tx:attributes>
56     </tx:advice>
57     
58     <!-- 3、配置事物切入点，再把事物属性和事务切入点关联起来 -->
59     <aop:config>
60         <aop:pointcut expression="execution(* com.service.*.*(..))" id="txPointcut"/>
61         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
62     </aop:config>
63     
64     <aop:config>
65         <aop:pointcut expression="execution (* com.service.CoreService.*(..))" id="txPointcut1"/>
66         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut1"/>
67     </aop:config>
68 
69 </beans>

再看看类路径下的db.properties文件：

jdbc.user=root
jdbc.password=tiger123
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/gzpp

jdbc.initialPoolSize=2
jdbc.maxPoolSize=10
jdbc.minPoolSize=1
jdbc.acquireIncrement=5
#...
#appSecret: 62e5c0141c2fc9a3bc9d2ae73fb7cd12
#appid: wx15fc2152e1406d02

由于mapping以及dataSource都在spring中配置完成了，所以hibernate.cfg.xml文件则相对简单：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7     
 8         <!-- 配置 hibernate 的基本属性 -->
 9     
10         <!-- 方言 -->
11         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
12         
13         <!-- 是否显示及格式化 SQL -->
14         <property name="hibernate.show_sql">true</property>
15         <property name="hibernate.format_sql">true</property>
16     
17         <!-- 生成数据表的策略 -->
18         <property name="hibernate.hbm2ddl.auto">update</property>
19         
20         <!-- 二级缓存相关 -->
21     
22     </session-factory>
23 </hibernate-configuration>