import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
public void configure(Map configurationValues) {
	ClassLoaderService classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
	ConfigurationPropertyReader propertyReader = new ConfigurationPropertyReader(
			configurationValues,
			classLoaderService
	);

	try {
		this.config = new RedisConfiguration( propertyReader );
	}
	catch (Exception e) {
		// Wrap Exception in a ServiceException to make the stack trace more friendly
		// Otherwise a generic unable to request service is thrown
		throw log.unableToConfigureDatastoreProvider( e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
public BatchBuilder initiateService(Map configurationValues, ServiceRegistryImplementor registry) {
	final Object builder = configurationValues.get( BUILDER );
	if ( builder == null ) {
		return new BatchBuilderImpl(
				ConfigurationHelper.getInt( Environment.STATEMENT_BATCH_SIZE, configurationValues, 1 )
		);
	}

	if ( BatchBuilder.class.isInstance( builder ) ) {
		return (BatchBuilder) builder;
	}

	final String builderClassName = builder.toString();
	try {
		return (BatchBuilder) registry.getService( ClassLoaderService.class ).classForName( builderClassName ).newInstance();
	}
	catch (Exception e) {
		throw new ServiceException( "Could not build explicit BatchBuilder [" + builderClassName + "]", e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
public String getImportedClassName(String className) {
	String result = imports.get( className );
	if ( result == null ) {
		try {
			serviceRegistry.getService( ClassLoaderService.class ).classForName( className );
			imports.put( className, className );
			return className;
		}
		catch ( ClassLoadingException cnfe ) {
			return null;
		}
	}
	else {
		return result;
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
/**
 * Builds the selector.
 *
 * @param classLoaderService The class loading service used to (attempt to) resolve any un-registered
 * strategy implementations.
 *
 * @return The selector.
 */
public StrategySelector buildSelector(ClassLoaderService classLoaderService) {
	final StrategySelectorImpl strategySelector = new StrategySelectorImpl( classLoaderService );

	// build the baseline...
	addDialects( strategySelector );
	addJtaPlatforms( strategySelector );
	addTransactionFactories( strategySelector );
	addMultiTableBulkIdStrategies( strategySelector );
	addEntityCopyObserverStrategies( strategySelector );

	// apply auto-discovered registrations
	for ( StrategyRegistrationProvider provider : classLoaderService.loadJavaServices( StrategyRegistrationProvider.class ) ) {
		for ( StrategyRegistration discoveredStrategyRegistration : provider.getStrategyRegistrations() ) {
			applyFromStrategyRegistration( strategySelector, discoveredStrategyRegistration );
		}
	}

	// apply customizations
	for ( StrategyRegistration explicitStrategyRegistration : explicitStrategyRegistrations ) {
		applyFromStrategyRegistration( strategySelector, explicitStrategyRegistration );
	}

	return strategySelector;
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
/**
 * Constructs a BootstrapServiceRegistryImpl.
 *
 * Do not use directly generally speaking.  Use {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder}
 * instead.
 *
 * @param autoCloseRegistry See discussion on
 * {@link org.hibernate.boot.registry.BootstrapServiceRegistryBuilder#disableAutoClose}
 * @param classLoaderService The ClassLoaderService to use
 * @param providedIntegrators The group of explicitly provided integrators
 *
 * @see org.hibernate.boot.registry.BootstrapServiceRegistryBuilder
 */
public BootstrapServiceRegistryImpl(
		boolean autoCloseRegistry,
		ClassLoaderService classLoaderService,
		LinkedHashSet<Integrator> providedIntegrators) {
	this.autoCloseRegistry = autoCloseRegistry;

	this.classLoaderServiceBinding = new ServiceBinding<ClassLoaderService>(
			this,
			ClassLoaderService.class,
			classLoaderService
	);

	final StrategySelectorImpl strategySelector = new StrategySelectorImpl( classLoaderService );
	this.strategySelectorBinding = new ServiceBinding<StrategySelector>(
			this,
			StrategySelector.class,
			strategySelector
	);

	this.integratorServiceBinding = new ServiceBinding<IntegratorService>(
			this,
			IntegratorService.class,
			new IntegratorServiceImpl( providedIntegrators, classLoaderService )
	);
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
public void contribute(InFlightMetadataCollector metadataCollector, IndexView jandexIndex) {
    MetadataBuildingOptions options = metadataCollector.getMetadataBuildingOptions();
    ClassLoaderService classLoaderService = options.getServiceRegistry().getService(ClassLoaderService.class);

    final ClassLoaderAccess classLoaderAccess = new ClassLoaderAccessImpl(
            options.getTempClassLoader(),
            classLoaderService
    );

    this.metadataBuildingContext = new MetadataBuildingContextRootImpl(
            options,
            classLoaderAccess,
            metadataCollector
    );

        java.util.Collection<PersistentEntity> persistentEntities = hibernateMappingContext.getPersistentEntities();
    for (PersistentEntity persistentEntity : persistentEntities) {
        if(!persistentEntity.getJavaClass().isAnnotationPresent(Entity.class)) {
            if(ConnectionSourcesSupport.usesConnectionSource(persistentEntity, dataSourceName) && persistentEntity.isRoot()) {
                bindRoot((HibernatePersistentEntity) persistentEntity, metadataCollector, sessionFactoryName);
            }
        }
    }
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
private boolean isBeanValidationApiAvailable(ClassLoaderService classLoaderService) {
	try {
		classLoaderService.classForName( BV_CHECK_CLASS );
		return true;
	}
	catch (Exception e) {
		return false;
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
private Class loadTypeSafeActivatorClass(ClassLoaderService classLoaderService) {
	try {
		return classLoaderService.classForName( ACTIVATOR_CLASS_NAME );
	}
	catch (Exception e) {
		throw new HibernateException( "Unable to load TypeSafeActivator class", e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
protected QueryCacheFactory createQueryCacheFactory(Properties properties, ServiceRegistry serviceRegistry) {
	String queryCacheFactoryClassName = ConfigurationHelper.getString(
			AvailableSettings.QUERY_CACHE_FACTORY, properties, StandardQueryCacheFactory.class.getName()
	);
	LOG.debugf( "Query cache factory: %s", queryCacheFactoryClassName );
	try {
		return (QueryCacheFactory) serviceRegistry.getService( ClassLoaderService.class )
				.classForName( queryCacheFactoryClassName )
				.newInstance();
	}
	catch (Exception e) {
		throw new HibernateException( "could not instantiate QueryCacheFactory: " + queryCacheFactoryClassName, e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
protected QueryTranslatorFactory createQueryTranslatorFactory(Properties properties, ServiceRegistry serviceRegistry) {
	String className = ConfigurationHelper.getString(
			AvailableSettings.QUERY_TRANSLATOR, properties, "org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory"
	);
	LOG.debugf( "Query translator: %s", className );
	try {
		return (QueryTranslatorFactory) serviceRegistry.getService( ClassLoaderService.class )
				.classForName( className )
				.newInstance();
	}
	catch ( Exception e ) {
		throw new HibernateException( "could not instantiate QueryTranslatorFactory: " + className, e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
public static Class classForName(String className, ServiceRegistry serviceRegistry) {
	ClassLoaderService classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
	try {
		return classLoaderService.classForName( className );
	}
	catch ( ClassLoadingException e ) {
		throw new MappingException( "Could not find class: " + className );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
public static <T> T getValue(AnnotationInstance annotation, String element, Class<T> type,
		ClassLoaderService classLoaderService) throws AssertionFailure {
	if ( Class.class.equals( type ) ) {
		throw new AssertionFailure(
				"Annotation parameters of type Class should be retrieved as strings (fully qualified class names)"
		);
	}

	if ( type.isPrimitive() ) {
		type = PrimitiveWrapperHelper.getDescriptorByPrimitiveType( type ).getWrapperClass();
	}

	// try getting the untyped value from Jandex
	AnnotationValue annotationValue = annotation.value( element );

	try {
		if ( annotationValue != null ) {
			return explicitAnnotationParameter( annotationValue, type );
		}
		else {
			return defaultAnnotationParameter( getDefaultValue( annotation, element, classLoaderService ), type );
		}
	}
	catch ( ClassCastException e ) {
		throw new AssertionFailure(
				String.format(
						"the annotation property %s of annotation %s is not of type %s",
						element,
						annotation.name(),
						type.getName()
				),
				e
		);
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
/**
 * Creates a jandex index for the specified classes
 *
 * @param classLoaderService class loader service
 * @param classes the classes to index
 *
 * @return an annotation repository w/ all the annotation discovered in the specified classes
 */
public static Index indexForClass(ClassLoaderService classLoaderService, Class<?>... classes) {
	Indexer indexer = new Indexer();
	for ( Class<?> clazz : classes ) {
		InputStream stream = classLoaderService.locateResourceStream(
				clazz.getName().replace( '.', '/' ) + ".class"
		);
		try {
			indexer.index( stream );
		}
		catch ( IOException e ) {
			StringBuilder builder = new StringBuilder();
			builder.append( "[" );
			int count = 0;
			for ( Class<?> c : classes ) {
				builder.append( c.getName() );
				if ( count < classes.length - 1 ) {
					builder.append( "," );
				}
				count++;
			}
			builder.append( "]" );
			throw new HibernateException( "Unable to create annotation index for " + builder.toString() );
		}
	}
	return indexer.complete();
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
public AnnotationBindingContextImpl(MetadataImplementor metadata, Index index) {
	this.metadata = metadata;
	this.classLoaderService = new ValueHolder<ClassLoaderService>(
			new ValueHolder.DeferredInitializer<ClassLoaderService>() {
				@Override
				public ClassLoaderService initialize() {
					return AnnotationBindingContextImpl.this.metadata
							.getServiceRegistry()
							.getService( ClassLoaderService.class );
				}
			}
	);
	this.index = index;
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
static AnnotationTarget getTarget(ServiceRegistry serviceRegistry, ClassInfo classInfo, String name, TargetType type) {
	Class clazz = serviceRegistry.getService( ClassLoaderService.class ).classForName( classInfo.toString() );
	switch ( type ) {
		case FIELD:
			Field field = getField( clazz, name );
			if ( field == null ) {
				throw new HibernateException(
						"Unable to load field "
								+ name
								+ " of class " + clazz.getName()
				);
			}

			return FieldInfo.create(
					classInfo, name, getType( field.getType() ), (short) ( field.getModifiers() )
			);
		case METHOD:
			Method method = getMethod( clazz, name );
			if ( method == null ) {
				throw new HibernateException(
						"Unable to load method "
								+ name
								+ " of class " + clazz.getName()
				);
			}
			return getMethodInfo( classInfo, method );
		case PROPERTY:
			method = getterMethod( clazz, name );
			if ( method == null ) {
				throw new HibernateException(
						"Unable to load property "
								+ name
								+ " of class " + clazz.getName()
				);
			}
			return getMethodInfo( classInfo, method );

	}
	throw new HibernateException( "" );
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
private void indexClass(Indexer indexer, String className) {
	InputStream stream = metadata.getServiceRegistry().getService( ClassLoaderService.class ).locateResourceStream(
			className
	);
	try {
		indexer.index( stream );
	}
	catch ( IOException e ) {
		throw new HibernateException( "Unable to open input stream for class " + className, e );
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
public JavaType(final String name, final ClassLoaderService classLoaderService) {
	this.name = name;
	this.classReference = new ValueHolder<Class<?>>(
			new ValueHolder.DeferredInitializer<Class<?>>() {
				@Override
				public Class<?> initialize() {
					return classLoaderService.classForName( name );
				}
			}
	);
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
public ImportSqlCommandExtractor initiateService(Map configurationValues, ServiceRegistryImplementor registry) {
	String extractorClassName = (String) configurationValues.get( Environment.HBM2DDL_IMPORT_FILES_SQL_EXTRACTOR );
	if ( StringHelper.isEmpty( extractorClassName ) ) {
		return DEFAULT_EXTRACTOR;
	}
	final ClassLoaderService classLoaderService = registry.getService( ClassLoaderService.class );
	return instantiateExplicitCommandExtractor( extractorClassName, classLoaderService );
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
private ImportSqlCommandExtractor instantiateExplicitCommandExtractor(String extractorClassName,
																	  ClassLoaderService classLoaderService) {
	try {
		return (ImportSqlCommandExtractor) classLoaderService.classForName( extractorClassName ).newInstance();
	}
	catch ( Exception e ) {
		throw new HibernateException(
				"Could not instantiate import sql command extractor [" + extractorClassName + "]", e
		);
	}
}
 

import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; //导入依赖的package包/类
@Override
protected TransactionManager locateTransactionManager() {
	try {
		Class transactionManagerServicesClass = serviceRegistry().getService( ClassLoaderService.class ).classForName( TM_CLASS_NAME );
		final Method getTransactionManagerMethod = transactionManagerServicesClass.getMethod( "getTransactionManager" );
		return (TransactionManager) getTransactionManagerMethod.invoke( null );
	}
	catch (Exception e) {
		throw new JtaPlatformException( "Could not locate Bitronix TransactionManager", e );
	}
}