作为javar的必学框架,我相信Hibernate源码也是被研究过无数次了。不过,别人研究过不代表我就不需要看了。
这里我以我的视野简单的过一遍。各位iteye的朋友有时间可以看看。如何已经很熟悉这个了就不用看了,否则看也是浪费时间。我研究的方法非常简单,就是反复读源码,一遍不行,二遍,或者三遍。。。
从Hibernate源码看它的启动过程:
Hibernate的启动是从Configuration开始的。Configuration既是它的配置中心,也是它的启动最初点。
Configuration提供了几个重载的configure方法,用来读取配置,默认,当然就是hibernate.cfg.xml。
configure调用doConfigure,返回Configuration。
doConfigure(org.dom4j.Document doc)很重要:
protected Configuration doConfigure(org.dom4j.Document doc) throws HibernateException {
//获取session-factory节点sfNode
Element sfNode = doc.getRootElement().element( "session-factory" );
String name = sfNode.attributeValue( "name" );
if ( name != null ) {
properties.setProperty( Environment.SESSION_FACTORY_NAME, name );
}
//处理sfNode的子节点property
addProperties( sfNode );
//处理sfNode的其他子节点,主要是mapping、listener、event
parseSessionFactory( sfNode, name );
Element secNode = doc.getRootElement().element( "security" );
if ( secNode != null ) {
parseSecurity( secNode );//处理doc的其他子节点,security,一般用的少
}
return this;
}
mapping 是关键,类似下面的配置
<mapping resource="com/bjsxt/drp/business/itemmgr/model/DataDict.hbm.xml"/>
protected void parseMappingElement(Element subelement, String name) {
Attribute rsrc = subelement.attribute( "resource" );
Attribute file = subelement.attribute( "file" );
Attribute jar = subelement.attribute( "jar" );
Attribute pkg = subelement.attribute( "package" );
Attribute clazz = subelement.attribute( "class" );
addResource( rsrc.getValue() );
addJar( new File( jar.getValue() ) );
addFile( file.getValue() );
}
常用的当然就是addResource,它调用addInputStream,然后是add(org.dom4j.Document doc),然后是HbmBinder.bindRoot( doc, createMappings(), CollectionHelper.EMPTY_MAP );
HbmBinder相当重要,他处理了Xxx.hbm.xml的各种配置;
——Walks an XML mapping document and produces the Hibernate configuration-time metamodel (the classes in the mapping)
bindRoot首先处理package属性,然后是其下面的各种元素:
filter-def
typedef
class: 通过bindRootClass-bindRootPersistentClassCommonValues处理class下的 property元素等
subclass
typedef
query
sql-query
import
database-object
else if ( "class".equals( elementName ) ) {
RootClass rootclass = new RootClass();
bindRootClass( element, rootclass, mappings, inheritedMetas );
mappings.addClass( rootclass );
}
---->>>
public static void bindRootClass(Element node, RootClass rootClass, Mappings mappings,
java.util.Map inheritedMetas) throws MappingException {
bindClass( node, rootClass, mappings, inheritedMetas );
inheritedMetas = getMetas( node, inheritedMetas, true ); // get meta's from <class>
bindRootPersistentClassCommonValues( node, inheritedMetas, mappings, rootClass );
}
继续跟踪,我们发现,类似 Xxx.hbm.xml的配置,里面的class元素,都被放到了 RootClass 里面:
public class RootClass extends PersistentClass implements TableOwner
它是一个实际对数据进行封装的类,主要是封装了下面的 属性,及对应的setter、getter方法。
private Property identifierProperty; //may be final
private KeyValue identifier; //may be final
private Property version; //may be final
private boolean polymorphic;
private String cacheConcurrencyStrategy;
private String cacheRegionName;
private boolean lazyPropertiesCacheable = true;
private Value discriminator; //may be final
private boolean mutable = true;
private boolean embeddedIdentifier = false; // may be final
private boolean explicitPolymorphism;
private Class entityPersisterClass;
private boolean forceDiscriminator = false;
private String where;
private Table table;
private boolean discriminatorInsertable = true;
private int nextSubclassId = 0;
PersistentClass 也是很重要,——Mapping for an entity
bindClass主要对 class里面的属性进行处理;
而bindRootPersistentClassCommonValues是对class下元素进行处理;
bindRootPersistentClassCommonValues很重要,二级缓存标签cache 也是在这里进行处理的!
private static void bindRootPersistentClassCommonValues(Element node,
java.util.Map inheritedMetas, Mappings mappings, RootClass entity)
throws MappingException {
// DB-OBJECTNAME
Attribute schemaNode = node.attribute( "schema" );
String schema = schemaNode == null ?
mappings.getSchemaName() : schemaNode.getValue();
Attribute catalogNode = node.attribute( "catalog" );
String catalog = catalogNode == null ?
mappings.getCatalogName() : catalogNode.getValue();
Table table = mappings.addTable(
schema,
catalog,
getClassTableName( entity, node, schema, catalog, null, mappings ),
getSubselect( node ),
entity.isAbstract() != null && entity.isAbstract().booleanValue()
);
entity.setTable( table );
bindComment(table, node);
// MUTABLE
Attribute mutableNode = node.attribute( "mutable" );
entity.setMutable( ( mutableNode == null ) || mutableNode.getValue().equals( "true" ) );
// WHERE
Attribute whereNode = node.attribute( "where" );
if ( whereNode != null ) entity.setWhere( whereNode.getValue() );
// CHECK
Attribute chNode = node.attribute( "check" );
if ( chNode != null ) table.addCheckConstraint( chNode.getValue() );
// POLYMORPHISM
Attribute polyNode = node.attribute( "polymorphism" );
entity.setExplicitPolymorphism( ( polyNode != null )
&& polyNode.getValue().equals( "explicit" ) );
// ROW ID
Attribute rowidNode = node.attribute( "rowid" );
if ( rowidNode != null ) table.setRowId( rowidNode.getValue() );
Iterator subnodes = node.elementIterator();
while ( subnodes.hasNext() ) {
Element subnode = (Element) subnodes.next();
String name = subnode.getName();
if ( "id".equals( name ) ) {
// ID
bindSimpleId( subnode, entity, mappings, inheritedMetas );
}
else if ( "composite-id".equals( name ) ) {
// COMPOSITE-ID
bindCompositeId( subnode, entity, mappings, inheritedMetas );
}
else if ( "version".equals( name ) || "timestamp".equals( name ) ) {
// VERSION / TIMESTAMP
bindVersioningProperty( table, subnode, mappings, name, entity, inheritedMetas );
}
else if ( "discriminator".equals( name ) ) {
// DISCRIMINATOR
bindDiscriminatorProperty( table, entity, subnode, mappings );
}
else if ( "cache".equals( name ) ) {
entity.setCacheConcurrencyStrategy( subnode.attributeValue( "usage" ) );
entity.setCacheRegionName( subnode.attributeValue( "region" ) );
entity.setLazyPropertiesCacheable( !"non-lazy".equals( subnode.attributeValue( "include" ) ) );
}
}
// Primary key constraint
entity.createPrimaryKey();
createClassProperties( node, entity, mappings, inheritedMetas );
}
这个类,我还没完全看懂,众所周知,hibernate的配置相当繁多复杂。我就常常记不住,有一次面试的时候,面试官问我hibernate的父类子类继承关系怎么配置,我记不得,所以也说不清。。。 给他留下不好印象。启动,先说到这里。有时间再仔细看看。
总之,configure之后,hibernate的配置就生效,可以使用了!
比如,通过配置获取可使用的 SessionFactory :
factory = cfg.buildSessionFactory();// 获取 factory 是hibernate 许多框架发挥巨大作用的最基础!
等等。
当然,我们一般不用直接通过,Configuration的静态方法configure来启动hibernate。在web应用中,我们通过web容器的相关配置来启动。
比如,在和struts集成(没有spring)的时候,我们通常写一个类似HibernateUtil负责从配置文件中获取、关闭SessionFactory :
public class HibernateUtils {
private static SessionFactory factory;
static {
try {
Configuration cfg = new Configuration().configure();
factory = cfg.buildSessionFactory();
}catch(Exception e) {
e.printStackTrace();
}
}
public static SessionFactory getSessionFactory() {
return factory;
}
public static Session getSession() {
return factory.openSession();
}
public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
}
当然,这其实还是要
Configuration cfg = new Configuration().configure();
factory = cfg.buildSessionFactory();
但由于他是静态初始化块的,所以配置只会被读取一次。当然,session还是要每次来获取的:
factory.openSession(),(是否每次打开同一个session根据情况需要)
factory还提供了api来获取不同的session:
openSession()
openSession(Connection connection)
openSession(Interceptor interceptor)
getCurrentSession()
openStatelessSession()
openStatelessSession(Connection connection)
另外,我们可以通过其他方式启动hibernate,插件方式:
先
import org.apache.struts.action.PlugIn;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.config.ModuleConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletContext;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernatePlugIn implements PlugIn {
public void destroy() {
}
public void init(ActionServlet servlet, ModuleConfig config)
throws ServletException {
try {
ServletContext context = servlet.getServletContext();
SessionFactory sf = new Configuration().configure()
.buildSessionFactory();
context.setAttribute("org.hibernate.SessionFactory", sf);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
然后在struts-config.xml配置插件信息:
<plug-in className="homepage.HibernatePlugIn"> <set-property property="configFilePath" value="/WEB-INF/classes/hibernate.cfg.xml" /> <set-property property="storeInServletContext" value="true" />
</plug-in>
然后利用java.naming.Context,java.naming.InitiaContext来查找
Context ct = new InitialContext();
sessions=(SessionFactory) ct.lookup("hibernate/session_factory");
session=sessions.openSession();
然后再封装成类似HibernateUtil的类,然后就可以在action中使用了。
如果集成在spring中,我们通常有如下的配置:
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
从而通过org.springframework.orm.hibernate3.LocalSessionFactoryBean读取hibernate配置,进而在必要的时候使用hibernateapi,可以说,它这个包装是很有用的。
spring提供有用的HibernateDaoSupport类,简化业务中对数据库的交互:
我们在业务中(通常是dao层)只要继承HibernateDaoSupport,然后再在spring对齐做相应的配置,就可以直接使用HibernateDaoSupport提供的getHibernateTemplate()来获取所需的hibernate session相关方法了,如
save、load、query、update、delete等