下面列出了怎么用org.hibernate.service.Service的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public void contribute(StandardServiceRegistryBuilder serviceRegistryBuilder) {
serviceRegistryBuilder
// The custom Hibernate schema management tool for Spanner.
.addInitiator(new StandardServiceInitiator() {
@Override
public Service initiateService(Map configurationValues,
ServiceRegistryImplementor registry) {
return SCHEMA_MANAGEMENT_TOOL;
}
@Override
public Class getServiceInitiated() {
return SchemaManagementTool.class;
}
})
// The user agent JDBC connection property to identify the library.
.applySetting("hibernate.connection.userAgent", HIBERNATE_API_CLIENT_LIB_TOKEN)
// Create a unique index for a table if it does not already exist when in UPDATE mode.
.applySetting(
"hibernate.schema_update.unique_constraint_strategy",
UniqueConstraintSchemaUpdateStrategy.RECREATE_QUIETLY)
// Allows entities to be used with InheritanceType.JOINED in Spanner.
.applySetting("hibernate.hql.bulk_id_strategy", InlineIdsOrClauseBulkIdStrategy.INSTANCE);
}
private <R extends Service> R initializeService(ServiceBinding<R> serviceBinding) {
if ( log.isTraceEnabled() ) {
log.tracev( "Initializing service [role={0}]", serviceBinding.getServiceRole().getName() );
}
// PHASE 1 : create service
R service = createService( serviceBinding );
if ( service == null ) {
return null;
}
// PHASE 2 : inject service (***potentially recursive***)
serviceBinding.getLifecycleOwner().injectDependencies( serviceBinding );
// PHASE 3 : configure service
serviceBinding.getLifecycleOwner().configureService( serviceBinding );
// PHASE 4 : Start service
serviceBinding.getLifecycleOwner().startService( serviceBinding );
return service;
}
@Override
public void registerService(Manageable service, Class<? extends Service> serviceRole) {
if ( OptionallyManageable.class.isInstance( service ) ) {
for ( Manageable realManageable : ( (OptionallyManageable) service ).getRealManageables() ) {
registerService( realManageable,serviceRole );
}
return;
}
final String domain = service.getManagementDomain() == null
? AvailableSettings.JMX_DEFAULT_OBJ_NAME_DOMAIN
: service.getManagementDomain();
final String serviceType = service.getManagementServiceType() == null
? service.getClass().getName()
: service.getManagementServiceType();
try {
final ObjectName objectName = new ObjectName(
String.format(
OBJ_NAME_TEMPLATE,
domain,
sessionFactoryName,
serviceRole.getName(),
serviceType
)
);
registerMBean( objectName, service.getManagementBean() );
}
catch ( MalformedObjectNameException e ) {
throw new HibernateException( "Unable to generate service IbjectName", e );
}
}
protected <R extends Service> void createServiceBinding(ProvidedService<R> providedService) {
ServiceBinding<R> binding = locateServiceBinding( providedService.getServiceRole(), false );
if ( binding == null ) {
binding = new ServiceBinding<R>( this, providedService.getServiceRole(), providedService.getService() );
serviceBindingMap.put( providedService.getServiceRole(), binding );
}
registerService( binding, providedService.getService() );
}
@Override
public <R extends Service> R getService(Class<R> serviceRole) {
// TODO: should an exception be thrown if active == false???
R service = serviceRole.cast( initializedServiceByRole.get( serviceRole ) );
if ( service != null ) {
return service;
}
//Any service initialization needs synchronization
synchronized ( this ) {
// Check again after having acquired the lock:
service = serviceRole.cast( initializedServiceByRole.get( serviceRole ) );
if ( service != null ) {
return service;
}
final ServiceBinding<R> serviceBinding = locateServiceBinding( serviceRole );
if ( serviceBinding == null ) {
throw new UnknownServiceException( serviceRole );
}
service = serviceBinding.getService();
if ( service == null ) {
service = initializeService( serviceBinding );
}
if ( service != null ) {
// add the service only after it is completely initialized
initializedServiceByRole.put( serviceRole, service );
}
return service;
}
}
@Override
public <R extends Service> void injectDependencies(ServiceBinding<R> serviceBinding) {
final R service = serviceBinding.getService();
applyInjections( service );
if ( ServiceRegistryAwareService.class.isInstance( service ) ) {
( (ServiceRegistryAwareService) service ).injectServices( this );
}
}
private <R extends Service> void applyInjections(R service) {
try {
for ( Method method : service.getClass().getMethods() ) {
InjectService injectService = method.getAnnotation( InjectService.class );
if ( injectService == null ) {
continue;
}
processInjection( service, method, injectService );
}
}
catch (NullPointerException e) {
log.error( "NPE injecting service deps : " + service.getClass().getName() );
}
}
@SuppressWarnings({ "unchecked" })
private <T extends Service> void processInjection(T service, Method injectionMethod, InjectService injectService) {
if ( injectionMethod.getParameterTypes() == null || injectionMethod.getParameterCount() != 1 ) {
throw new ServiceDependencyException(
"Encountered @InjectService on method with unexpected number of parameters"
);
}
Class dependentServiceRole = injectService.serviceRole();
if ( dependentServiceRole == null || dependentServiceRole.equals( Void.class ) ) {
dependentServiceRole = injectionMethod.getParameterTypes()[0];
}
// todo : because of the use of proxies, this is no longer returning null here...
final Service dependantService = getService( dependentServiceRole );
if ( dependantService == null ) {
if ( injectService.required() ) {
throw new ServiceDependencyException(
"Dependency [" + dependentServiceRole + "] declared by service [" + service + "] not found"
);
}
}
else {
try {
injectionMethod.invoke( service, dependantService );
}
catch ( Exception e ) {
throw new ServiceDependencyException( "Cannot inject dependency service", e );
}
}
}
@Override
@SuppressWarnings({ "unchecked" })
public <R extends Service> void startService(ServiceBinding<R> serviceBinding) {
if ( Startable.class.isInstance( serviceBinding.getService() ) ) {
( (Startable) serviceBinding.getService() ).start();
}
if ( Manageable.class.isInstance( serviceBinding.getService() ) ) {
getService( JmxService.class ).registerService(
(Manageable) serviceBinding.getService(),
serviceBinding.getServiceRole()
);
}
}
@Override
public <R extends Service> void stopService(ServiceBinding<R> binding) {
final Service service = binding.getService();
if ( Stoppable.class.isInstance( service ) ) {
try {
( (Stoppable) service ).stop();
}
catch ( Exception e ) {
log.unableToStopService( service.getClass(), e.toString() );
}
}
}
@Override
@SuppressWarnings( {"unchecked"})
public <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole) {
if ( ClassLoaderService.class.equals( serviceRole ) ) {
return (ServiceBinding<R>) classLoaderServiceBinding;
}
else if ( StrategySelector.class.equals( serviceRole) ) {
return (ServiceBinding<R>) strategySelectorBinding;
}
else if ( IntegratorService.class.equals( serviceRole ) ) {
return (ServiceBinding<R>) integratorServiceBinding;
}
return null;
}
@Override
public <R extends Service> void stopService(ServiceBinding<R> binding) {
final Service service = binding.getService();
if ( Stoppable.class.isInstance( service ) ) {
try {
( (Stoppable) service ).stop();
}
catch ( Exception e ) {
LOG.unableToStopService( service.getClass(), e.toString() );
}
}
}
@Override
public <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole) {
return null;
}
@Override @SuppressWarnings("unchecked")
public <R extends Service> R getService(Class<R> serviceRole) {
if ( serviceRole == VertxInstance.class ) {
return (R) vertxService;
}
else if ( serviceRole == JdbcEnvironment.class ) {
return (R) new JdbcEnvironment() {
@Override
public Dialect getDialect() {
return new MySQL8Dialect();
}
@Override
public ExtractedDatabaseMetaData getExtractedDatabaseMetaData() {
return null;
}
@Override
public Identifier getCurrentCatalog() {
return null;
}
@Override
public Identifier getCurrentSchema() {
return null;
}
@Override
public QualifiedObjectNameFormatter getQualifiedObjectNameFormatter() {
return null;
}
@Override
public IdentifierHelper getIdentifierHelper() {
return null;
}
@Override
public NameQualifierSupport getNameQualifierSupport() {
return null;
}
@Override
public SqlExceptionHelper getSqlExceptionHelper() {
return null;
}
@Override
public LobCreatorBuilder getLobCreatorBuilder() {
return null;
}
@Override
public TypeInfo getTypeInfoForJdbcCode(int jdbcTypeCode) {
return null;
}
};
}
else {
throw new IllegalArgumentException( "This is a mock service - need to explicitly handle any service we might need during testing" );
}
}
/**
* @return the list of services to get from the service registry and turn into provided services
*/
public List<Class<? extends Service>> getPostBuildProvidedServices() {
return postBuildProvidedServices;
}
@Override
public void registerService(Manageable service, Class<? extends Service> serviceRole) {
// no-op
}
@SuppressWarnings("unchecked")
public FastBootMetadataBuilder(final PersistenceUnitDescriptor persistenceUnit, Scanner scanner,
Collection<Class<? extends Integrator>> additionalIntegrators, PreGeneratedProxies preGeneratedProxies,
MultiTenancyStrategy strategy) {
this.persistenceUnit = persistenceUnit;
this.additionalIntegrators = additionalIntegrators;
this.preGeneratedProxies = preGeneratedProxies;
final ClassLoaderService providedClassLoaderService = FlatClassLoaderService.INSTANCE;
// Copying semantics from: new EntityManagerFactoryBuilderImpl( unit,
// integration, instance );
// Except we remove support for several legacy features and XML binding
final ClassLoader providedClassLoader = null;
LogHelper.logPersistenceUnitInformation(persistenceUnit);
// Build the boot-strap service registry, which mainly handles class loader
// interactions
final BootstrapServiceRegistry bsr = buildBootstrapServiceRegistry(providedClassLoaderService);
// merge configuration sources and build the "standard" service registry
final RecordableBootstrap ssrBuilder = new RecordableBootstrap(bsr);
final MergedSettings mergedSettings = mergeSettings(persistenceUnit);
this.buildTimeSettings = new BuildTimeSettings(mergedSettings.getConfigurationValues());
// Build the "standard" service registry
ssrBuilder.applySettings(buildTimeSettings.getSettings());
this.standardServiceRegistry = ssrBuilder.build();
registerIdentifierGenerators(standardServiceRegistry);
this.providedServices = ssrBuilder.getProvidedServices();
/**
* This is required to properly integrate Hibernate Envers.
*
* The EnversService requires multiple steps to be properly built, the most important ones are:
*
* 1. The EnversServiceContributor contributes the EnversServiceInitiator to the RecordableBootstrap.
* 2. After RecordableBootstrap builds a StandardServiceRegistry, the first time the EnversService is
* requested, it is created by the initiator and configured by the registry.
* 3. The MetadataBuildingProcess completes by calling the AdditionalJaxbMappingProducer which
* initializes the EnversService and produces some additional mapping documents.
* 4. After that point the EnversService appears to be fully functional.
*
* The following trick uses the aforementioned steps to setup the EnversService and then turns it into
* a ProvidedService so that it is not necessary to repeat all these complex steps during the reactivation
* of the destroyed service registry in PreconfiguredServiceRegistryBuilder.
*
*/
for (Class<? extends Service> postBuildProvidedService : ssrBuilder.getPostBuildProvidedServices()) {
providedServices.add(new ProvidedService(postBuildProvidedService,
standardServiceRegistry.getService(postBuildProvidedService)));
}
final MetadataSources metadataSources = new MetadataSources(bsr);
addPUManagedClassNamesToMetadataSources(persistenceUnit, metadataSources);
this.metamodelBuilder = (MetadataBuilderImplementor) metadataSources
.getMetadataBuilder(standardServiceRegistry);
if (scanner != null) {
this.metamodelBuilder.applyScanner(scanner);
}
populate(metamodelBuilder, mergedSettings.cacheRegionDefinitions, standardServiceRegistry);
this.managedResources = MetadataBuildingProcess.prepare(metadataSources,
metamodelBuilder.getBootstrapContext());
applyMetadataBuilderContributor();
// BVAL integration:
this.validatorFactory = withValidatorFactory(
buildTimeSettings.get(org.hibernate.cfg.AvailableSettings.JPA_VALIDATION_FACTORY));
// Unable to automatically handle:
// AvailableSettings.ENHANCER_ENABLE_DIRTY_TRACKING,
// AvailableSettings.ENHANCER_ENABLE_LAZY_INITIALIZATION,
// AvailableSettings.ENHANCER_ENABLE_ASSOCIATION_MANAGEMENT
// for the time being we want to revoke access to the temp ClassLoader if one
// was passed
metamodelBuilder.applyTempClassLoader(null);
if (strategy != null && strategy != MultiTenancyStrategy.NONE) {
ssrBuilder.addService(MultiTenantConnectionProvider.class, new HibernateMultiTenantConnectionProvider());
}
this.multiTenancyStrategy = strategy;
}
@SuppressWarnings( {"unchecked"})
SessionFactoryServiceRegistryBuilder addService(Class serviceRole, Service service);
@Override
public <R extends Service> R initiateService(ServiceInitiator<R> serviceInitiator) {
SessionFactoryServiceInitiator<R> sessionFactoryServiceInitiator = (SessionFactoryServiceInitiator<R>) serviceInitiator;
return sessionFactoryServiceInitiator.initiateService( this );
}
@Override
public <R extends Service> void configureService(ServiceBinding<R> serviceBinding) {
if ( Configurable.class.isInstance( serviceBinding.getService() ) ) {
( (Configurable) serviceBinding.getService() ).configure( getService( ConfigurationService.class ).getSettings() );
}
}
@SuppressWarnings({ "unchecked" })
protected <R extends Service> void createServiceBinding(ServiceInitiator<R> initiator) {
final ServiceBinding serviceBinding = new ServiceBinding( this, initiator );
serviceBindingMap.put( initiator.getServiceInitiated(), serviceBinding );
}
@Override
@SuppressWarnings({ "unchecked" })
public <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole) {
return locateServiceBinding( serviceRole, true );
}
@SuppressWarnings({ "unchecked" })
protected <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole, boolean checkParent) {
ServiceBinding<R> serviceBinding = serviceBindingMap.get( serviceRole );
if ( serviceBinding == null && checkParent && parent != null ) {
// look in parent
serviceBinding = parent.locateServiceBinding( serviceRole );
}
if ( serviceBinding != null ) {
return serviceBinding;
}
if ( !allowCrawling ) {
return null;
}
// look for a previously resolved alternate registration
final Class alternative = roleXref.get( serviceRole );
if ( alternative != null ) {
return serviceBindingMap.get( alternative );
}
// perform a crawl looking for an alternate registration
for ( ServiceBinding binding : serviceBindingMap.values() ) {
if ( serviceRole.isAssignableFrom( binding.getServiceRole() ) ) {
// we found an alternate...
log.alternateServiceRole( serviceRole.getName(), binding.getServiceRole().getName() );
registerAlternate( serviceRole, binding.getServiceRole() );
return binding;
}
if ( binding.getService() != null && serviceRole.isInstance( binding.getService() ) ) {
// we found an alternate...
log.alternateServiceRole( serviceRole.getName(), binding.getServiceRole().getName() );
registerAlternate( serviceRole, binding.getServiceRole() );
return binding;
}
}
return null;
}
protected <R extends Service> void registerService(ServiceBinding<R> serviceBinding, R service) {
serviceBinding.setService( service );
synchronized ( serviceBindingList ) {
serviceBindingList.add( serviceBinding );
}
}
@Override
public <R extends Service> R getService(Class<R> serviceRole) {
final ServiceBinding<R> binding = locateServiceBinding( serviceRole );
return binding == null ? null : binding.getService();
}
@Override
public <R extends Service> R initiateService(ServiceInitiator<R> serviceInitiator) {
throw new ServiceException( "Boot-strap registry should only contain provided services" );
}
@Override
public <R extends Service> void configureService(ServiceBinding<R> binding) {
throw new ServiceException( "Boot-strap registry should only contain provided services" );
}
@Override
public <R extends Service> void injectDependencies(ServiceBinding<R> binding) {
throw new ServiceException( "Boot-strap registry should only contain provided services" );
}
@Override
public <R extends Service> void startService(ServiceBinding<R> binding) {
throw new ServiceException( "Boot-strap registry should only contain provided services" );
}
@Override
public <R extends Service> R initiateService(ServiceInitiator<R> serviceInitiator) {
// todo : add check/error for unexpected initiator types?
return ( (StandardServiceInitiator<R>) serviceInitiator ).initiateService( configurationValues, this );
}