@Override @SuppressWarnings({ "unchecked" }) public <R extends Service> ServiceBinding<R> locateServiceBinding(Class<R> serviceRole) { return locateServiceBinding( serviceRole, true ); }
@Override public SessionFactoryServiceRegistryFactoryImpl initiateService(Map configurationValues, ServiceRegistryImplementor registry) { return new SessionFactoryServiceRegistryFactoryImpl( registry ); } }
public SessionFactoryServiceRegistry buildSessionFactoryServiceRegistry( SessionFactoryImplementor sessionFactory, SessionFactoryOptions options) { return new SessionFactoryServiceRegistryImpl( parent, initiators, providedServices, sessionFactory, options ); } }
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() ); }
/** * Adds a user-provided service. * * @param serviceRole The role of the service being added * @param service The service implementation * * @return this, for method chaining */ @SuppressWarnings({"unchecked"}) public StandardServiceRegistryBuilder addService(final Class serviceRole, final Service service) { providedServices.add( new ProvidedService( serviceRole, service ) ); return this; }
@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 public SessionFactoryServiceRegistry buildServiceRegistry( SessionFactoryImplementor sessionFactory, SessionFactoryOptions options) { final ClassLoaderService cls = options.getServiceRegistry().getService( ClassLoaderService.class ); final SessionFactoryServiceRegistryBuilderImpl builder = new SessionFactoryServiceRegistryBuilderImpl( theBasicServiceRegistry ); for ( SessionFactoryServiceContributor contributor : cls.loadJavaServices( SessionFactoryServiceContributor.class ) ) { contributor.contribute( builder ); } return builder.buildSessionFactoryServiceRegistry( sessionFactory, options ); } }
@Override public <R extends Service> R getService(Class<R> serviceRole) { //HHH-11051 cache EventListenerRegistry if ( serviceRole.equals( EventListenerRegistry.class ) ) { if ( cachedEventListenerRegistry == null ) { cachedEventListenerRegistry = (EventListenerRegistry) super.getService( serviceRole ); } return (R) cachedEventListenerRegistry; } return super.getService( serviceRole ); }
@SuppressWarnings( {"unchecked"}) public SessionFactoryServiceRegistryImpl( ServiceRegistryImplementor parent, List<SessionFactoryServiceInitiator> initiators, List<ProvidedService> providedServices, SessionFactoryImplementor sessionFactory, SessionFactoryOptions sessionFactoryOptions) { super( parent ); this.sessionFactory = sessionFactory; this.sessionFactoryOptions = sessionFactoryOptions; // for now, just use the standard initiator list for ( SessionFactoryServiceInitiator initiator : initiators ) { // create the bindings up front to help identify to which registry services belong createServiceBinding( initiator ); } for ( ProvidedService providedService : providedServices ) { createServiceBinding( providedService ); } }
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() ); } }
@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> 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; }
/** * Very advanced and tricky to handle: not designed for this. Intended for experiments only! */ public synchronized void resetAndReactivate(BootstrapServiceRegistry bootstrapServiceRegistry, List<StandardServiceInitiator> serviceInitiators, List<ProvidedService> providedServices, Map<?, ?> configurationValues) { if ( super.isActive() ) { throw new IllegalStateException( "Can't reactivate an active registry!" ); } super.resetParent( bootstrapServiceRegistry ); this.configurationValues = new HashMap( configurationValues ); super.reactivate(); applyServiceRegistrations( serviceInitiators, providedServices ); }
@Override public <R extends Service> void configureService(ServiceBinding<R> serviceBinding) { if ( Configurable.class.isInstance( serviceBinding.getService() ) ) { ( (Configurable) serviceBinding.getService() ).configure( getService( ConfigurationService.class ).getSettings() ); } }
@Override public synchronized void destroy() { super.destroy(); this.cachedEventListenerRegistry = null; }
/** * Adds a user-provided service. * * @param serviceRole The role of the service being added * @param service The service implementation * * @return this, for method chaining */ @Override @SuppressWarnings( {"unchecked"}) public SessionFactoryServiceRegistryBuilder addService(final Class serviceRole, final Service service) { providedServices.add( new ProvidedService( serviceRole, service ) ); return this; }
@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 synchronized void destroy() { super.destroy(); this.configurationValues = null; } }
private static ProvidedService connectionProviderService() { return new ProvidedService<ConnectionProvider>( ConnectionProvider.class, ConnectionProviderBuilder.buildConnectionProvider( true ) ); }
private static ProvidedService dialectFactoryService() { return new ProvidedService<DialectFactory>( DialectFactory.class, new DialectFactoryTestingImpl() ); }