【hibernate源码解析】之SessionFactory

最新推荐文章于 2025-06-21 12:26:40 发布
原创 最新推荐文章于 2025-06-21 12:26:40 发布 · 977 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文将探讨Hibernate的SessionFactory，它是构建Session实例的核心。SessionFactory通过Configuration、mapping类和Settings类实例初始化，其中Settings类解析配置文件参数。此外，还涉及到SessionFactoryObserver，用于监控SessionFactory的开启和关闭。我们将深入SessionFactoryImpl的构造方法，揭示其内部工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SessionFactory负责构建Session实例，就像在Configuration解析中，首先给出的那段代码：

private static SessionFactory sf = null;
	
	static{
		Configuration configuration = new Configuration();
		configuration.configure("cn/huawei/config/hibernate.cfg.xml");
		configuration.addClass(Customer.class);
		sf = configuration.buildSessionFactory();
	}
configuration.buildSessionFactory()方法来返回Session的实例。那么hibernate程序是如何构建Session的实例的呢？我们从代码中找找看，当然这还是离不开Configuration这个类，还是得从这个类开始，找到buildSessionFactory()这个方法。看下面的代码： 

public SessionFactory buildSessionFactory() throws HibernateException {
		log.debug( "Preparing to build session factory with filters : " + filterDefinitions );
		secondPassCompile();
		validate();
		Environment.verifyProperties( properties );
		Properties copy = new Properties();
		copy.putAll( properties );
		PropertiesHelper.resolvePlaceHolders( copy );
		Settings settings = buildSettings( copy );

		return new SessionFactoryImpl(
				this,
				mapping,
				settings,
				getInitializedEventListeners(),
				sessionFactoryObserver
			);
	}
这个方法返回的是一个sessionFactory的实例。首先我们来分析一下这个方法，这个方法是先对property这个变量里的值进行了校验，至于怎么校验的，咱们一会儿再说，校验完了之后，程序直接返回了一个new SessionFactoryImpl(this,mapping,settings,getInitializedEventListeners(),sessionFactoryObserver);咱们看一下这个方法的原始模型：
org.hibernate.impl.SessionFactoryImpl.SessionFactoryImpl(Configuration cfg, Mapping mapping, Settings settings, EventListeners listeners, SessionFactoryObserver observer) throws HibernateException

第一个参数是Configuration类的一个实例，第二个参数是mapping类的实例（里面是持久化类的一些属性），第三个参数是Settings类的实例，它通过buildSettings这个方法将配置文件中的值给解析出来方面以后使用；第四个参数是SessionFactoryObserver类型，主要的内容是观察SessionFactory打开还是关闭的。接下来我们就进入SessionFactoryImpl这个构造方法中去看看究竟：

public SessionFactoryImpl(
			Configuration cfg,
	        Mapping mapping,
	        Settings settings,
	        EventListeners listeners,
			SessionFactoryObserver observer) throws HibernateException {
		log.info("building session factory");

		Statistics concurrentStatistics = null;
		try {
			Class concurrentStatsClass = ReflectHelper.classForName("org.hibernate.stat.ConcurrentStatisticsImpl");
			Constructor constructor = concurrentStatsClass.getConstructor(new Class[]{SessionFactoryImplementor.class});
			concurrentStatistics = (Statistics) constructor.newInstance(new Object[]{this});
			log.trace("JDK 1.5 concurrent classes present");
		} catch ( NoClassDefFoundError noJava5 ) {
			log.trace("JDK 1.5 concurrent classes missing");
		} catch (Exception noJava5) {
			log.trace("JDK 1.5 concurrent classes missing");
		}

		if (concurrentStatistics != null) {
			this.statistics = concurrentStatistics;
		} else {
			this.statistics = new StatisticsImpl(this);
		}

		if ( log.isTraceEnabled() ) {
			log.trace("Statistics initialized with " + statistics.getClass().getName());
		}

		this.properties = new Properties();
		this.properties.putAll( cfg.getProperties() );
		this.interceptor = cfg.getInterceptor();
		this.settings = settings;
		this.sqlFunctionRegistry = new SQLFunctionRegistry(settings.getDialect(), cfg.getSqlFunctions());
        this.eventListeners = listeners;
		this.observer = observer != null ? observer : new SessionFactoryObserver() {
			public void sessionFactoryCreated(SessionFactory factory) {
			}
			public void sessionFactoryClosed(SessionFactory factory) {
			}
		};

		this.filters = new HashMap();
		this.filters.putAll( cfg.getFilterDefinitions() );

		if ( log.isDebugEnabled() ) {
			log.debug("Session factory constructed with filter configurations : " + filters);
		}

		if ( log.isDebugEnabled() ) {
			log.debug(
					"instantiating session factory with properties: " + properties
			);
		}

		// Caches
		settings.getRegionFactory().start( settings, properties );

		//Generators:

		identifierGenerators = new HashMap();
		Iterator classes = cfg.getClassMappings();
		while ( classes.hasNext() ) {
			PersistentClass model = (PersistentClass) classes.next();
			if ( !model.isInherited() ) {
				IdentifierGenerator generator = model.getIdentifier().createIdentifierGenerator(
						cfg.getIdentifierGeneratorFactory(),
						settings.getDialect(),
				        settings.getDefaultCatalogName(),
				        settings.getDefaultSchemaName(),
				        (RootClass) model
				);
				identifierGenerators.put( model.getEntityName(), generator );
			}
		}


		///////////////////////////////////////////////////////////////////////
		// Prepare persisters and link them up with their cache
		// region/access-strategy

		final String cacheRegionPrefix = settings.getCacheRegionPrefix() == null ? "" : settings.getCacheRegionPrefix() + ".";

		entityPersisters = new HashMap();
		Map entityAccessStrategies = new HashMap();
		Map classMeta = new HashMap();
		classes = cfg.getClassMappings();
		while ( classes.hasNext() ) {
			final PersistentClass model = (PersistentClass) classes.next();
			model.prepareTemporaryTables( mapping, settings.getDialect() );
			final String cacheRegionName = cacheRegionPrefix + model.getRootClass().getCacheRegionName();
			// cache region is defined by the root-class in the hierarchy...
			EntityRegionAccessStrategy accessStrategy = ( EntityRegionAccessStrategy ) entityAccessStrategies.get( cacheRegionName );
			if ( accessStrategy == null && settings.isSecondLevelCacheEnabled() ) {
				final AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );
				if ( accessType != null ) {
					log.trace( "Building cache for entity data [" + model.getEntityName() + "]" );
					EntityRegion entityRegion = settings.getRegionFactory().buildEntityRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );
					accessStrategy = entityRegion.buildAccessStrategy( accessType );
					entityAccessStrategies.put( cacheRegionName, accessStrategy );
					allCacheRegions.put( cacheRegionName, entityRegion );
				}
			}
			EntityPersister cp = PersisterFactory.createClassPersister( model, accessStrategy, this, mapping );
			entityPersisters.put( model.getEntityName(), cp );
			classMeta.put( model.getEntityName(), cp.getClassMetadata() );
		}
		classMetadata = Collections.unmodifiableMap(classMeta);

		Map tmpEntityToCollectionRoleMap = new HashMap();
		collectionPersisters = new HashMap();
		Iterator collections = cfg.getCollectionMappings();
		while ( collections.hasNext() ) {
			Collection model = (Collection) collections.next();
			final String cacheRegionName = cacheRegionPrefix + model.getCacheRegionName();
			final AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );
			CollectionRegionAccessStrategy accessStrategy = null;
			if ( accessType != null && settings.isSecondLevelCacheEnabled() ) {
				log.trace( "Building cache for collection data [" + model.getRole() + "]" );
				CollectionRegion collectionRegion = settings.getRegionFactory().buildCollectionRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );
				accessStrategy = collectionRegion.buildAccessStrategy( accessType );
				entityAccessStrategies.put( cacheRegionName, accessStrategy );
				allCacheRegions.put( cacheRegionName, collectionRegion );
			}
			CollectionPersister persister = PersisterFactory.createCollectionPersister( cfg, model, accessStrategy, this) ;
			collectionPersisters.put( model.getRole(), persister.getCollectionMetadata() );
			Type indexType = persister.getIndexType();
			if ( indexType != null && indexType.isAssociationType() && !indexType.isAnyType() ) {
				String entityName = ( ( AssociationType ) indexType ).getAssociatedEntityName( this );
				Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );
				if ( roles == null ) {
					roles = new HashSet();
					tmpEntityToCollectionRoleMap.put( entityName, roles );
				}
				roles.add( persister.getRole() );
			}
			Type elementType = persister.getElementType();
			if ( elementType.isAssociationType() && !elementType.isAnyType() ) {
				String entityName = ( ( AssociationType ) elementType ).getAssociatedEntityName( this );
				Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );
				if ( roles == null ) {
					roles = new HashSet();
					tmpEntityToCollectionRoleMap.put( entityName, roles );
				}
				roles.add( persister.getRole() );
			}
		}
		collectionMetadata = Collections.unmodifiableMap(collectionPersisters);
		Iterator itr = tmpEntityToCollectionRoleMap.entrySet().iterator();
		while ( itr.hasNext() ) {
			final Map.Entry entry = ( Map.Entry ) itr.next();
			entry.setValue( Collections.unmodifiableSet( ( Set ) entry.getValue() ) );
		}
		collectionRolesByEntityParticipant = Collections.unmodifiableMap( tmpEntityToCollectionRoleMap );

		//Named Queries:
		namedQueries = new HashMap( cfg.getNamedQueries() );
		namedSqlQueries = new HashMap( cfg.getNamedSQLQueries() );
		sqlResultSetMappings = new HashMap( cfg.getSqlResultSetMappings() );
		imports = new HashMap( cfg.getImports() );

		// after *all* persisters and named queries are registered
		Iterator iter = entityPersisters.values().iterator();
		while ( iter.hasNext() ) {
			final EntityPersister persister = ( ( EntityPersister ) iter.next() );
			persister.postInstantiate();
			registerEntityNameResolvers( persister );

		}
		iter = collectionPersisters.values().iterator();
		while ( iter.hasNext() ) {
			final CollectionPersister persister = ( ( CollectionPersister ) iter.next() );
			persister.postInstantiate();
		}

		//JNDI + Serialization:

		name = settings.getSessionFactoryName();
		try {
			uuid = (String) UUID_GENERATOR.generate(null, null);
		}
		catch (Exception e) {
			throw new AssertionFailure("Could not generate UUID");
		}
		SessionFactoryObjectFactory.addInstance(uuid, name, this, properties);

		log.debug("instantiated session factory");

		if ( settings.isAutoCreateSchema() ) {
			new SchemaExport( cfg, settings ).create( false, true );
		}
		if ( settings.isAutoUpdateSchema() ) {
			new SchemaUpdate( cfg, settings ).execute( false, true );
		}
		if ( settings.isAutoValidateSchema() ) {
			new SchemaValidator( cfg, settings ).validate();
		}
		if ( settings.isAutoDropSchema() ) {
			schemaExport = new SchemaExport( cfg, settings );
		}

		if ( settings.getTransactionManagerLookup()!=null ) {
			log.debug("obtaining JTA TransactionManager");
			transactionManager = settings.getTransactionManagerLookup().getTransactionManager(properties);
		}
		else {
			if ( settings.getTransactionFactory().isTransactionManagerRequired() ) {
				throw new HibernateException("The chosen transaction strategy requires access to the JTA TransactionManager");
			}
			transactionManager = null;
		}

		currentSessionContext = buildCurrentSessionContext();

		if ( settings.isQueryCacheEnabled() ) {
			updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
			queryCache = settings.getQueryCacheFactory()
			        .getQueryCache(null, updateTimestampsCache, settings, properties);
			queryCaches = new HashMap();
			allCacheRegions.put( updateTimestampsCache.getRegion().getName(), updateTimestampsCache.getRegion() );
			allCacheRegions.put( queryCache.getRegion().getName(), queryCache.getRegion() );
		}
		else {
			updateTimestampsCache = null;
			queryCache = null;
			queryCaches = null;
		}

		//checking for named queries
		if ( settings.isNamedQueryStartupCheckingEnabled() ) {
			Map errors = checkNamedQueries();
			if ( !errors.isEmpty() ) {
				Set keys = errors.keySet();
				StringBuffer failingQueries = new StringBuffer( "Errors in named queries: " );
				for ( Iterator iterator = keys.iterator() ; iterator.hasNext() ; ) {
					String queryName = ( String ) iterator.next();
					HibernateException e = ( HibernateException ) errors.get( queryName );
					failingQueries.append( queryName );
					if ( iterator.hasNext() ) {
						failingQueries.append( ", " );
					}
					log.error( "Error in named query: " + queryName, e );
				}
				throw new HibernateException( failingQueries.toString() );
			}
		}

		//stats
		getStatistics().setStatisticsEnabled( settings.isStatisticsEnabled() );

		// EntityNotFoundDelegate
		EntityNotFoundDelegate entityNotFoundDelegate = cfg.getEntityNotFoundDelegate();
		if ( entityNotFoundDelegate == null ) {
			entityNotFoundDelegate = new EntityNotFoundDelegate() {
				public void handleEntityNotFound(String entityName, Serializable id) {
					throw new ObjectNotFoundException( id, entityName );
				}
				public boolean isEntityNotFoundException(RuntimeException exception) {
					return ObjectNotFoundException.class.isInstance( exception );
				}
			};
		}
		this.entityNotFoundDelegate = entityNotFoundDelegate;

		// this needs to happen after persisters are all ready to go...
		this.fetchProfiles = new HashMap();
		itr = cfg.iterateFetchProfiles();
		while ( itr.hasNext() ) {
			final org.hibernate.mapping.FetchProfile mappingProfile =
					( org.hibernate.mapping.FetchProfile ) itr.next();
			final FetchProfile fetchProfile = new FetchProfile( mappingProfile.getName() );
			Iterator fetches = mappingProfile.getFetches().iterator();
			while ( fetches.hasNext() ) {
				final org.hibernate.mapping.FetchProfile.Fetch mappingFetch =
						( org.hibernate.mapping.FetchProfile.Fetch ) fetches.next();
				// resolve the persister owning the fetch
				final String entityName = getImportedClassName( mappingFetch.getEntity() );
				final EntityPersister owner = ( EntityPersister ) ( entityName == null ? null : entityPersisters.get( entityName ) );
				if ( owner == null ) {
					throw new HibernateException(
							"Unable to resolve entity reference [" + mappingFetch.getEntity()
									+ "] in fetch profile [" + fetchProfile.getName() + "]"
					);
				}

				// validate the specified association fetch
				Type associationType = owner.getPropertyType( mappingFetch.getAssociation() );
				if ( associationType == null || !associationType.isAssociationType() ) {
					throw new HibernateException( "Fetch profile [" + fetchProfile.getName() + "] specified an invalid association" );
				}

				// resolve the style
				final Fetch.Style fetchStyle = Fetch.Style.parse( mappingFetch.getStyle() );

				// then construct the fetch instance...
				fetchProfile.addFetch( new Association( owner, mappingFetch.getAssociation() ), fetchStyle );
				( ( Loadable ) owner ).registerAffectingFetchProfile( fetchProfile.getName() );
			}
			fetchProfiles.put( fetchProfile.getName(), fetchProfile );
		}

		this.observer.sessionFactoryCreated( this );
	}
看这段代码的最后一行this.observer.sessionFactoryCreated( this );通过这个SessionFactoryObserver将SessionFactory创建出来。




Hibernate源码分析
idearfly的专栏
09-14 2万+
这段时间本人利用空闲时间解读了一下Hibernate3的源码，饶有收获，愿与大家共享。 废话不多说，首先我们先对Hibernate有一个大致的印象l  设计模式Hibernate=监听器，实际上是回调l  Hibernate3支持拦截器 Hibernate配置方面的大原则：l  bhn.xml文件所有配置都是描述本实体，除了cascade描述级联，即如何将本实体的操作（
Hibernate源码解析
qq_37371027的博客
10-09 919
我在用了hibernate一段时间后，我把hibernate的源代码放在一个src下面，然后开始分析，第一步写一个junit，然后new了一个configuration,我发现configuration是用doConfigure去检测我的hibernate.cfg.xml将他转换成inputstream输出流对象，然后由dom4j进行解析，一旦发现xml的配置的格式有问题就会抛出一个异常，可是跟数
深入剖析Hibernate3源码：ORM框架与数据库操作原理
最新发布
weixin_36300623的博客
06-21 558
Hibernate3是一个强大的对象关系映射（ORM）框架，自2001年首次发布以来，它已成为Java社区中最为流行和广泛使用的持久化解决方案之一。Hibernate允许开发人员使用Java对象与数据库进行交互，从而简化了数据存取的过程。对象关系映射（ORM）是指通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。这种映射方式允许开发者以面向对象的方式来操作数据库，而不是编写大量的SQL语句。ORM的主要作用在于：提高开发效率。
Hibernate4.0之HibernateSessionFactory源码详解
aipiannian6725的博客
07-03 154
import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry; import org.hibernate.service.Ser...
Hibernate源码解析（一）
03-18
《Hibernate源码解析（一）》 在Java开发领域，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。深入理解Hibernate的源码，不仅可以帮助开发者更好地运用该工具，还能提升对Java编程和...
Hibernate源码解析（三）
07-26
《Hibernate源码解析（三）》这篇文章主要探讨了Hibernate框架的深入源码解析，这是对 Hibernate 框架理解的进一步深化。在本篇中，作者聚焦于几个关键的组件和机制，帮助读者理解 Hibernate 如何高效地管理和操作...
Hibernate源码解析（二）
07-03
在本篇《Hibernate源码解析（二）》中，我们将深入探讨Hibernate这一强大的Java对象关系映射（ORM）框架的内部工作原理。这篇博客旨在帮助开发者更好地理解Hibernate的核心机制，以便于更高效地利用它来处理数据库...
Hibernate源码解析：redsaga论坛教程指南
在redsaga论坛上讨论Hibernate源码，说明该论坛的用户群体对于Hibernate有较高的关注度和应用需求，同时也表明在论坛中可能存在着大量有关Hibernate源码分析和应用的讨论和资源。这对于寻找Hibernate源码分析资料和...
Hibernate源码解析：深入浅出的学习指南
本篇文档以“深入浅出Hibernate源码”为主题，将重点介绍Hibernate的内部工作机制，以及如何通过分析源码来加深对其使用和原理的理解。 Hibernate源码的深入研究不仅仅是为了理解其背后的实现细节，还能够帮助...
hibernate源码分析
08-31
Hibernate源码分析文档，解析Hibernate执行流程
HibernateSessionFactory 代码
10-15
Hibernate中涉及到的增加,删除,查询,修改,操作.
Hibernate中SessionFactoryImpl 修改 动态添加hbm xml文件
06-07
修改了Hibernate的源码，可动态增加映射文件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值