Hibernate源码分析

先扯二句蛋：做Java也有很久了，安卓也搞了半年，回想自己当初学习java，j2ee的时候，全靠自己，没有老师，没有同学，书籍就是老师，搜索引擎就是同学，磕磕绊绊下来，终于有所心得，从今天开始准备好好的写一些博客，希望能帮助到那些刚上路，或者在路上却有些迷茫的童鞋````
最近有在研究hibernate这个框架的源码，所以这一阶段会将自己的研究进度和心得用简单的方式贴出来，希望帮到大家的同时，大家也能指出其中的问题，一起讨论，共同进步！（注意：这是源码分析，需要对hibernate有一定了解，起码使用过，所以没有使用过hibernate的童鞋还是先去使用使用在来看吧，不然只能一头雾水`````）
那么就从头开始，且听我细细道来：
hibernate大家都用过，使用下面这个东西大家应该都很熟悉
Configuration cfg = new Configuration().configure();

SessionFactory factory = cfg.buildSessionFactory();
这样就获取到了我们Dao层中所需要的SessionFactory了

那么configure()这个方法中做了什么？上源码
public Configuration configure() throws HibernateException {
  configure( "/hibernate.cfg.xml" );
  return this;
}
看，这里就是去加载解析/hibernate.cfg.xml去了，显然是用configure（String resource）方法，这个方法做了什么？上源码
public Configuration configure(String resource) throws HibernateException {
  LOG.configuringFromResource( resource ); //打了个日志
  InputStream stream = getConfigurationInputStream( resource ); //获取这个xml文件的输入流
  return doConfigure( stream, resource );//用这个输入流去生成orm映射的对象了！
}

那doConfigure( stream, resource )做了什么？上源码
protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {
  try {
   ErrorLogger errorLogger = new ErrorLogger( resourceName );
   Document document = xmlHelper.createSAXReader( errorLogger,  entityResolver )
     .read( new InputSource( stream ) );//这里就用这个输入流去生成一个Document 对象了，很显然，hibernate使用了SAX解析
   if ( errorLogger.hasErrors() ) {
    throw new MappingException( "invalid configuration", errorLogger.getErrors().get( 0 ) );
   }
   doConfigure( document );//看，再一次调用了重载的 doConfigure( Document  document )方法
  }
  catch (DocumentException e) {
   throw new HibernateException( "Could not parse configuration: " + resourceName, e );
  }
  finally {
   try {
    stream.close();
   }
   catch (IOException ioe) {
    LOG.unableToCloseInputStreamForResource( resourceName, ioe );
   }
  }
  return this;
}

那么重载的 doConfigure( Document  document )方法中做了什么？上源码
protected Configuration doConfigure(Document doc) throws HibernateException {
  Element sfNode = doc.getRootElement().element( "session-factory" );
  String name = sfNode.attributeValue( "name" );
  if ( name != null ) {
   properties.setProperty( Environment.SESSION_FACTORY_NAME, name );
  }
  addProperties( sfNode );
  parseSessionFactory( sfNode, name );
  Element secNode = doc.getRootElement().element( "security" );
  if ( secNode != null ) {
   parseSecurity( secNode );
  }
  LOG.configuredSessionFactory( name );
  LOG.debugf( "Properties: %s", properties );
  return this;
}
很显然，这个方法处理了两个节点：session-factory和security
session-factory这个节点很是熟悉啊，自然是用来指明各个映射文件的
security节点再议
parseSessionFactory( sfNode, name );就是去利用这个节点去找到各个映射文件，然后做映射，完成orm
那他做了啥？上源码
private void parseSessionFactory(Element sfNode, String name) {
  Iterator elements = sfNode.elementIterator();
  while ( elements.hasNext() ) {
   Element subelement = (Element) elements.next();
   String subelementName = subelement.getName();
   if ( "mapping".equals( subelementName ) ) {
    parseMappingElement( subelement, name );
   }
   else if ( "class-cache".equals( subelementName ) ) {
    String className = subelement.attributeValue( "class" );
    Attribute regionNode = subelement.attribute( "region" );
    final String region = ( regionNode == null ) ? className : regionNode.getValue();
    boolean includeLazy = !"non-lazy".equals( subelement.attributeValue( "include" ) );
    setCacheConcurrencyStrategy( className, subelement.attributeValue( "usage" ), region, includeLazy );
   }
   else if ( "collection-cache".equals( subelementName ) ) {
    String role = subelement.attributeValue( "collection" );
    Attribute regionNode = subelement.attribute( "region" );
    final String region = ( regionNode == null ) ? role : regionNode.getValue();
    setCollectionCacheConcurrencyStrategy( role, subelement.attributeValue( "usage" ), region );
   }
  }
}

这里处理了3个节点mapping，class-cache，collection-cache，mapping节点很是熟悉啊，这就是咱为每个domain对象做的映射文件啊，其他两再议
处理mapping节点时调用了parseMappingElement( subelement, name );，那他做了啥？上源码
private void parseMappingElement(Element mappingElement, String name) {
  final Attribute resourceAttribute = mappingElement.attribute( "resource" );
  final Attribute fileAttribute = mappingElement.attribute( "file" );
  final Attribute jarAttribute = mappingElement.attribute( "jar" );
  final Attribute packageAttribute = mappingElement.attribute( "package" );
  final Attribute classAttribute = mappingElement.attribute( "class" );
  if ( resourceAttribute != null ) {
   final String resourceName = resourceAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named resource [%s] for mapping", name, resourceName );
   addResource( resourceName );
  }
  else if ( fileAttribute != null ) {
   final String fileName = fileAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named file [%s] for mapping", name, fileName );
   addFile( fileName );
  }
  else if ( jarAttribute != null ) {
   final String jarFileName = jarAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named jar file [%s] for mapping", name, jarFileName );
   addJar( new File( jarFileName ) );
  }
  else if ( packageAttribute != null ) {
   final String packageName = packageAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named package [%s] for mapping", name, packageName );
   addPackage( packageName );
  }
  else if ( classAttribute != null ) {
   final String className = classAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named class [%s] for mapping", name, className );
   try {
    addAnnotatedClass( ReflectHelper.classForName( className ) );
   }
   catch ( Exception e ) {
    throw new MappingException(
      "Unable to load class [ " + className + "] declared in Hibernate configuration <mapping/> entry",
      e
    );
   }
  }
  else {
   throw new MappingException( "<mapping> element in configuration specifies no known attributes" );
  }
}
很长，本着解决主要矛盾，忽略次要矛盾的马列哲学思想，我们还是来关注我们最熟悉的，用class来配置，也就是上面的
else if ( classAttribute != null ) {
   final String className = classAttribute.getValue();
   LOG.debugf( "Session-factory config [%s] named class [%s] for mapping", name, className );
   try {
    addAnnotatedClass( ReflectHelper.classForName( className ) );
   }
   catch ( Exception e ) {
    throw new MappingException(
      "Unable to load class [ " + className + "] declared in Hibernate configuration <mapping/> entry",
      e
    );
   }
两个LOG.debugf输出的文字很熟悉吧，就是hibernate启动时常常看见的，控制台打出的日志
那么 addAnnotatedClass( ReflectHelper.classForName( className ) );就是正式进入解析阶段了，且看具体做了什么，
首先不着急，我们看看ReflectHelper.classForName（className ），从名字就可以看出来用了反射技术去从className这个名字反射出一个类出来，暂时把他当做一个黑箱好了，只要知道传入一个对的名字就可以得到一个正确的Class类就ok了。
在得到类后传入看看做了啥：
@SuppressWarnings({ "unchecked" })
public Configuration addAnnotatedClass(Class annotatedClass) {
  XClass xClass = reflectionManager.toXClass( annotatedClass );
  metadataSourceQueue.add( xClass );
  return this;
}
言简意赅，用了一个ReflectionManager对象的toXClass将我们的Class变成了Hibernate自定义的XClass，然后在metadataSourceQueue这个队列中加入了这个XClass，然后一个个映射就出炉了！以后我们就直接使用内存中的队列metadataSourceQueue就ok了
整个解析过程就是这个样子，看Hibernate源码果真是一种享受，很通俗易懂，言简意赅，不想某些公司的项目代码，简直一团乱麻！
ok，不抱怨了，且看几个细节问题，XClass究竟为何物，为何要将Class转化为XClass,MetadataSourceQueue又是何物？
且听下回分解