org.hibernate.bytecode.enhance.spi.EnhancementContext Java Examples

@Override
public void pushClassTransformer(EnhancementContext enhancementContext) {
}
 

@Override
public void pushClassTransformer(final EnhancementContext enhancementContext) {
    // has never been supported
}
 

public EnhancingClassTransformerImpl(EnhancementContext enhancementContext) {
	this.enhancementContext = enhancementContext;
}
 

private EntityManagerFactoryBuilderImpl(
		PersistenceUnitDescriptor persistenceUnit,
		Map integrationSettings,
		ClassLoader providedClassLoader,
		ClassLoaderService providedClassLoaderService) {

	LogHelper.logPersistenceUnitInformation( persistenceUnit );

	this.persistenceUnit = persistenceUnit;

	if ( integrationSettings == null ) {
		integrationSettings = Collections.emptyMap();
	}

	// Build the boot-strap service registry, which mainly handles class loader interactions
	final BootstrapServiceRegistry bsr = buildBootstrapServiceRegistry( integrationSettings, providedClassLoader, providedClassLoaderService);

	// merge configuration sources and build the "standard" service registry
	final StandardServiceRegistryBuilder ssrBuilder = new StandardServiceRegistryBuilder( bsr );
	final MergedSettings mergedSettings = mergeSettings( persistenceUnit, integrationSettings, ssrBuilder );
	this.configurationValues = mergedSettings.getConfigurationValues();

	// Build the "standard" service registry
	ssrBuilder.applySettings( configurationValues );
	configure( ssrBuilder );
	this.standardServiceRegistry = ssrBuilder.build();
	configure( standardServiceRegistry, mergedSettings );

	final MetadataSources metadataSources = new MetadataSources( bsr );
	List<AttributeConverterDefinition> attributeConverterDefinitions = populate(
			metadataSources,
			mergedSettings,
			standardServiceRegistry
	);
	this.metamodelBuilder = (MetadataBuilderImplementor) metadataSources.getMetadataBuilder( standardServiceRegistry );
	populate( metamodelBuilder, mergedSettings, standardServiceRegistry, attributeConverterDefinitions );

	// todo : would be nice to have MetadataBuilder still do the handling of CfgXmlAccessService here
	//		another option is to immediately handle them here (probably in mergeSettings?) as we encounter them...
	final CfgXmlAccessService cfgXmlAccessService = standardServiceRegistry.getService( CfgXmlAccessService.class );
	if ( cfgXmlAccessService.getAggregatedConfig() != null ) {
		if ( cfgXmlAccessService.getAggregatedConfig().getMappingReferences() != null ) {
			for ( MappingReference mappingReference : cfgXmlAccessService.getAggregatedConfig().getMappingReferences() ) {
				mappingReference.apply( metadataSources );
			}
		}
	}

	this.managedResources = MetadataBuildingProcess.prepare(
			metadataSources,
			metamodelBuilder.getBootstrapContext()
	);

	applyMetadataBuilderContributor();


	withValidatorFactory( configurationValues.get( org.hibernate.cfg.AvailableSettings.JPA_VALIDATION_FACTORY ) );

	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// push back class transformation to the environment; for the time being this only has any effect in EE
	// container situations, calling back into PersistenceUnitInfo#addClassTransformer

	final boolean dirtyTrackingEnabled = readBooleanConfigurationValue( AvailableSettings.ENHANCER_ENABLE_DIRTY_TRACKING );
	final boolean lazyInitializationEnabled = readBooleanConfigurationValue( AvailableSettings.ENHANCER_ENABLE_LAZY_INITIALIZATION );
	final boolean associationManagementEnabled = readBooleanConfigurationValue( AvailableSettings.ENHANCER_ENABLE_ASSOCIATION_MANAGEMENT );

	if ( dirtyTrackingEnabled || lazyInitializationEnabled || associationManagementEnabled ) {
		EnhancementContext enhancementContext = getEnhancementContext(
				dirtyTrackingEnabled,
				lazyInitializationEnabled,
				associationManagementEnabled
		);

		persistenceUnit.pushClassTransformer( enhancementContext );
	}

	// for the time being we want to revoke access to the temp ClassLoader if one was passed
	metamodelBuilder.applyTempClassLoader( null );
}
 

@Override
public void pushClassTransformer(EnhancementContext enhancementContext) {
	// todo : log a message that this is currently not supported...
}
 

@Override
public void pushClassTransformer(EnhancementContext enhancementContext) {
	persistenceUnitInfo.addTransformer( new EnhancingClassTransformerImpl( enhancementContext ) );
}
 

public JavassistEnhancementContext(EnhancementContext enhancementContext) {
	this.enhancementContext = enhancementContext;
}
 

ByteBuddyEnhancementContext(EnhancementContext enhancementContext) {
	this.enhancementContext = enhancementContext;
}
 

@Override
public Enhancer getEnhancer(EnhancementContext enhancementContext) {
	return new EnhancerImpl( enhancementContext );
}
 

@Override
public Enhancer getEnhancer(EnhancementContext enhancementContext) {
	return new EnhancerImpl( enhancementContext, byteBuddyState );
}
 

@Override
public void pushClassTransformer(EnhancementContext enhancementContext) {
	descriptor.pushClassTransformer(enhancementContext);
}
 

/**
 * Constructs the Enhancer, using the given context.
 *
 * @param enhancementContext Describes the context in which enhancement will occur so as to give access
 * to contextual/environmental information.
 */
public EnhancerImpl(EnhancementContext enhancementContext) {
	this.enhancementContext = new JavassistEnhancementContext( enhancementContext );
	this.classPool = buildClassPool( this.enhancementContext );
}
 

/**
 * Constructs the Enhancer, using the given context.
 *
 * @param enhancementContext Describes the context in which enhancement will occur so as to give access
 * to contextual/environmental information.
 * @param byteBuddyState refers to the ByteBuddy instance to use
 */
public EnhancerImpl(final EnhancementContext enhancementContext, final ByteBuddyState byteBuddyState) {
	this.enhancementContext = new ByteBuddyEnhancementContext( enhancementContext );
	this.byteBuddyState = byteBuddyState;
	this.typePool = buildTypePool( this.enhancementContext );
}
 

/**
 * Returns a byte code enhancer that implements the enhancements described in the supplied enhancement context.
 *
 * @param enhancementContext The enhancement context that describes the enhancements to apply.
 *
 * @return An enhancer to perform byte code manipulations.
 */
Enhancer getEnhancer(EnhancementContext enhancementContext);
 

public void pushClassTransformer(EnhancementContext enhancementContext);