org.hibernate.boot.SessionFactoryBuilder Java Examples

@Override
public void generateSchema() {
	// This seems overkill, but building the SF is necessary to get the Integrators to kick in.
	// Metamodel will clean this up...
	try {
		SessionFactoryBuilder sfBuilder = metadata().getSessionFactoryBuilder();
		populate( sfBuilder, standardServiceRegistry );

		SchemaManagementToolCoordinator.process(
				metadata, standardServiceRegistry, configurationValues, DelayedDropRegistryNotAvailableImpl.INSTANCE
		);
	}
	catch (Exception e) {
		throw persistenceException( "Error performing schema management", e );
	}

	// release this builder
	cancel();
}
 

@Override
public <T extends SessionFactoryBuilder> T unwrap(Class<T> type) {
	if ( type.isAssignableFrom( getClass() ) ) {
		return type.cast( this );
	}
	else {
		return delegate.unwrap( type );
	}
}
 

@Override
public SessionFactoryBuilder applyEntityTuplizer(
		EntityMode entityMode,
		Class<? extends EntityTuplizer> tuplizerClass) {
	this.optionsBuilder.applyEntityTuplizer( entityMode, tuplizerClass );
	return this;
}
 

/**
 * Builds the actual {@link SessionFactory} from the builder.
 *
 * @param sessionFactoryBuilder The {@link SessionFactoryBuilder}
 * @return The {@link SessionFactory}
 */
@Context
@Requires(beans = SessionFactoryBuilder.class)
@Bean(preDestroy = "close")
@EachBean(SessionFactoryBuilder.class)
protected SessionFactory hibernateSessionFactory(SessionFactoryBuilder sessionFactoryBuilder) {
    return sessionFactoryBuilder.build();
}
 

@Override
public SessionFactoryBuilder getSessionFactoryBuilder(
        MetadataImplementor metadata,
        SessionFactoryBuilderImplementor defaultBuilder) {
    List<String> handled = new ArrayList<>();
    for (PersistentClass entity : metadata.getEntityBindings()) {
        bind(entity, handled);
    }
    return null;
}
 

@SuppressWarnings("unchecked")
public EntityManagerFactory build() {
	SessionFactoryBuilder sfBuilder = metadata().getSessionFactoryBuilder();
	populate( sfBuilder, standardServiceRegistry );

	try {
		return sfBuilder.build();
	}
	catch (Exception e) {
		throw persistenceException( "Unable to build Hibernate SessionFactory", e );
	}
}
 

@Override
public SessionFactoryBuilder getSessionFactoryBuilder() {
	throw new UnsupportedOperationException(
			"You should not be building a SessionFactory from an in-flight metadata collector; and of course " +
					"we should better segment this in the API :)"
	);
}
 

private static SessionFactoryBuilder getSessionFactoryBuilder(ServiceRegistry serviceRegistry) {
    MetadataSources metadataSources = new MetadataSources(serviceRegistry);
    metadataSources.addAnnotatedClass(FootballPlayer.class);

    Metadata metadata = metadataSources.buildMetadata();
    return metadata.getSessionFactoryBuilder();

}
 

private static SessionFactoryBuilder getSessionFactoryBuilder(ServiceRegistry serviceRegistry) {
    MetadataSources metadataSources = new MetadataSources(serviceRegistry);
    metadataSources.addPackage("com.baeldung.hibernate.proxy");
    metadataSources.addAnnotatedClass(Company.class);
    metadataSources.addAnnotatedClass(Employee.class);

    Metadata metadata = metadataSources.buildMetadata();
    return metadata.getSessionFactoryBuilder();

}
 

private static SessionFactoryBuilder getSessionFactoryBuilder(ServiceRegistry serviceRegistry) {
    MetadataSources metadataSources = new MetadataSources(serviceRegistry);
    metadataSources.addPackage("com.baeldung.hibernate.interceptors");
    metadataSources.addAnnotatedClass(User.class);

    Metadata metadata = metadataSources.buildMetadata();
    return metadata.getSessionFactoryBuilder();

}
 

@Override
public SessionFactoryBuilder getSessionFactoryBuilder() {
	final SessionFactoryBuilderImpl defaultBuilder = new SessionFactoryBuilderImpl( this, bootstrapContext );

	final ClassLoaderService cls = metadataBuildingOptions.getServiceRegistry().getService( ClassLoaderService.class );
	final java.util.Collection<SessionFactoryBuilderFactory> discoveredBuilderFactories = cls.loadJavaServices( SessionFactoryBuilderFactory.class );

	SessionFactoryBuilder builder = null;
	List<String> activeFactoryNames = null;

	for ( SessionFactoryBuilderFactory discoveredBuilderFactory : discoveredBuilderFactories ) {
		final SessionFactoryBuilder returnedBuilder = discoveredBuilderFactory.getSessionFactoryBuilder( this, defaultBuilder );
		if ( returnedBuilder != null ) {
			if ( activeFactoryNames == null ) {
				activeFactoryNames = new ArrayList<>();
			}
			activeFactoryNames.add( discoveredBuilderFactory.getClass().getName() );
			builder = returnedBuilder;
		}
	}

	if ( activeFactoryNames != null && activeFactoryNames.size() > 1 ) {
		throw new HibernateException(
				"Multiple active SessionFactoryBuilderFactory definitions were discovered : " +
						String.join(", ", activeFactoryNames)
		);
	}

	if ( builder != null ) {
		return builder;
	}

	return defaultBuilder;
}
 

@Override
public SessionFactoryBuilder applyJdbcFetchSize(int size) {
	this.optionsBuilder.applyJdbcFetchSize( size );
	return this;
}
 

@Override
public SessionFactoryBuilder applyQuerySubstitutions(Map substitutions) {
	this.optionsBuilder.applyQuerySubstitutions( substitutions );
	return this;
}
 

@Override
public SessionFactoryBuilder applyNamedQueryCheckingOnStartup(boolean enabled) {
	this.optionsBuilder.enableNamedQueryCheckingOnStartup( enabled );
	return this;
}
 

@Override
public SessionFactoryBuilder applySecondLevelCacheSupport(boolean enabled) {
	this.optionsBuilder.enableSecondLevelCacheSupport( enabled );
	return this;
}
 

@Override
public SessionFactoryBuilder enableJpaQueryCompliance(boolean enabled) {
	this.optionsBuilder.enableJpaQueryCompliance( enabled );
	return this;
}
 

private SessionFactory newSessionFactory() {
    final BootstrapServiceRegistryBuilder bsrb = new BootstrapServiceRegistryBuilder()
        .enableAutoClose();

    Integrator integrator = integrator();
    if (integrator != null) {
        bsrb.applyIntegrator( integrator );
    }

    final BootstrapServiceRegistry bsr = bsrb.build();

    final StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder(bsr)
        .applySettings(properties())
        .build();

    final MetadataSources metadataSources = new MetadataSources(serviceRegistry);

    for (Class annotatedClass : entities()) {
        metadataSources.addAnnotatedClass(annotatedClass);
    }

    String[] packages = packages();
    if (packages != null) {
        for (String annotatedPackage : packages) {
            metadataSources.addPackage(annotatedPackage);
        }
    }

    String[] resources = resources();
    if (resources != null) {
        for (String resource : resources) {
            metadataSources.addResource(resource);
        }
    }

    final MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder()
    .enableNewIdentifierGeneratorSupport(true)
    .applyImplicitNamingStrategy(ImplicitNamingStrategyLegacyJpaImpl.INSTANCE);

    final List<Type> additionalTypes = additionalTypes();
    if (additionalTypes != null) {
        additionalTypes.stream().forEach(type -> {
            metadataBuilder.applyTypes((typeContributions, sr) -> {
                if(type instanceof BasicType) {
                    typeContributions.contributeType((BasicType) type);
                } else if (type instanceof UserType ){
                    typeContributions.contributeType((UserType) type);
                } else if (type instanceof CompositeUserType) {
                    typeContributions.contributeType((CompositeUserType) type);
                }
            });
        });
    }

    additionalMetadata(metadataBuilder);

    MetadataImplementor metadata = (MetadataImplementor) metadataBuilder.build();

    final SessionFactoryBuilder sfb = metadata.getSessionFactoryBuilder();
    Interceptor interceptor = interceptor();
    if(interceptor != null) {
        sfb.applyInterceptor(interceptor);
    }

    return sfb.build();
}
 

@Override
public SessionFactoryBuilder applyConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode) {
	this.optionsBuilder.applyConnectionReleaseMode( connectionReleaseMode );
	return this;
}
 

@Override
public SessionFactoryBuilder applyConnectionHandlingMode(PhysicalConnectionHandlingMode connectionHandlingMode) {
	this.optionsBuilder.applyConnectionHandlingMode( connectionHandlingMode );
	return this;
}
 

@Override
public SessionFactoryBuilder enableJpaListCompliance(boolean enabled) {
	this.optionsBuilder.enableJpaListCompliance( enabled );
	return this;
}
 

@Override
public SessionFactoryBuilder applyCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver resolver) {
	this.optionsBuilder.applyCurrentTenantIdentifierResolver( resolver );
	return this;
}
 

@Override
public SessionFactoryBuilder applyMultiTenancyStrategy(MultiTenancyStrategy strategy) {
	this.optionsBuilder.applyMultiTenancyStrategy( strategy );
	return this;
}
 

@Override
public SessionFactoryBuilder getSessionFactoryBuilder( MetadataImplementor metadataImplementor, SessionFactoryBuilderImplementor defaultBuilder )
{
    HibernateMetadata.metadataImplementor.set( metadataImplementor );
    return defaultBuilder;
}
 

@Override
public SessionFactoryBuilder applyMaximumFetchDepth(int depth) {
	this.optionsBuilder.applyMaximumFetchDepth( depth );
	return this;
}
 

@Override
public SessionFactoryBuilder applyDefaultBatchFetchSize(int size) {
	this.optionsBuilder.applyDefaultBatchFetchSize( size );
	return this;
}
 

@Override
public SessionFactoryBuilder applyDelayedEntityLoaderCreations(boolean delay) {
	this.optionsBuilder.applyDelayedEntityLoaderCreations( delay );
	return this;
}
 

@Override
public SessionFactoryBuilder applyBatchFetchStyle(BatchFetchStyle style) {
	this.optionsBuilder.applyBatchFetchStyle( style );
	return this;
}
 

@Override
public SessionFactoryBuilder applyTempTableDdlTransactionHandling(TempTableDdlTransactionHandling handling) {
	this.optionsBuilder.applyTempTableDdlTransactionHandling( handling );
	return this;
}
 

@Override
public SessionFactoryBuilder applyMultiTableBulkIdStrategy(MultiTableBulkIdStrategy strategy) {
	this.optionsBuilder.applyMultiTableBulkIdStrategy( strategy );
	return this;
}
 

@Override
public SessionFactoryBuilder applyEntityNotFoundDelegate(EntityNotFoundDelegate entityNotFoundDelegate) {
	this.optionsBuilder.applyEntityNotFoundDelegate( entityNotFoundDelegate );
	return this;
}