/** * Registers a non-component object that requires closing or shutdown when the repository stops. * * <p>Certain interfaces are automatically detected. If it implements {@code InitializingBean}, * then it will be initialized as though using {@link #initialize(InitializingBean)}. * * @param obj the object to close/shutdown, not null * @param methodName the method name to call, not null */ public void registerLifecycleStop(final Object obj, final String methodName) { ArgumentChecker.notNull(obj, "object"); ArgumentChecker.notNull(methodName, "methodName"); checkStatus(Status.CREATING); initialize0(obj); registerLifecycle0( new Lifecycle() { @Override public void stop() { ReflectionUtils.invokeNoArgsNoException(obj, methodName); } @Override public void start() {} @Override public boolean isRunning() { return false; } @Override public String toString() { return obj.getClass().getSimpleName() + ":" + obj.toString(); } }); _logger.logDebug(" Registered lifecycle-stop: " + obj); }
/** * Registers the component specifying the info that describes it. * * <p>Certain interfaces are automatically detected. If the component implements {@code * Lifecycle}, it will be registered as though using {@link #registerLifecycle(Lifecycle)}. If it * implements {@code ServletContextAware}, then it will be registered as though using {@link * #registerServletContextAware(ServletContextAware)}. If it implements {@code InitializingBean}, * then it will be initialized as though using {@link #initialize(InitializingBean)}. * * <p>If the component implements {@code FactoryBean}, it will be checked for the automatically * detected interfaces before the factory is evaluated. The evaluated factory will then be * registered, and the resulting object will again be checked for automatically detected * interfaces. * * @param info the component info to register, not null * @param instance the component instance to register, not null * @throws IllegalArgumentException if unable to register */ public void registerComponent(final ComponentInfo info, Object instance) { ArgumentChecker.notNull(info, "info"); ArgumentChecker.notNull(instance, "instance"); checkStatus(Status.CREATING); final ComponentKey key = info.toComponentKey(); try { // initialize initialize0(instance); registerInstanceInterfaces0(instance); // handle factories if (instance instanceof FactoryBean<?>) { try { instance = ((FactoryBean<?>) instance).getObject(); } catch (final Exception ex) { throw new OpenGammaRuntimeException("FactoryBean threw exception", ex); } initialize0(instance); registerInstanceInterfaces0(instance); } // register into data structures final Object current = _instanceMap.putIfAbsent(key, instance); if (current != null) { throw new IllegalArgumentException( "Component already registered for specified information: " + key); } _infoMap.putIfAbsent(info.getType(), new ComponentTypeInfo(info.getType())); final ComponentTypeInfo typeInfo = getTypeInfo(info.getType()); typeInfo.getInfoMap().put(info.getClassifier(), info); registeredComponent(info, instance); // If the component being registered is also an MBean, then register it as such if (JmxUtils.isMBean(instance.getClass())) { registerMBean(instance); } } catch (final RuntimeException ex) { _status.set(Status.FAILED); throw new RuntimeException("Failed during registration: " + key, ex); } }
/** * Registers a non-component object implementing {@code Lifecycle}. * * <p>Certain interfaces are automatically detected. If it implements {@code InitializingBean}, * then it will be initialized as though using {@link #initialize(InitializingBean)}. * * @param lifecycleObject the object that has a lifecycle, not null */ public void registerLifecycle(final Lifecycle lifecycleObject) { ArgumentChecker.notNull(lifecycleObject, "lifecycleObject"); checkStatus(Status.CREATING); try { initialize0(lifecycleObject); registerLifecycle0(lifecycleObject); _logger.logDebug(" Registered lifecycle: " + lifecycleObject); } catch (final RuntimeException ex) { _status.set(Status.FAILED); throw new RuntimeException("Failed during registering Lifecycle: " + lifecycleObject, ex); } }
/** * Registers a non-component object implementing {@code Lifecycle}. * * <p>Certain interfaces are automatically detected. If it implements {@code InitializingBean}, * then it will be initialized as though using {@link #initialize(InitializingBean)}. * * @param servletContextAware the object that requires a servlet context, not null */ public void registerServletContextAware(final ServletContextAware servletContextAware) { ArgumentChecker.notNull(servletContextAware, "servletContextAware"); checkStatus(Status.CREATING); try { initialize0(servletContextAware); registerServletContextAware0(servletContextAware); _logger.logDebug(" Registered lifecycle-stop: " + servletContextAware); } catch (final RuntimeException ex) { _status.set(Status.FAILED); throw new RuntimeException( "Failed during registering ServletContextAware: " + servletContextAware, ex); } }
/** * Registers an instance that should be treated as a JMX Managed Resource. * * @param managedResource the object that should be treated as an MBean * @param name The fully qualified JMX ObjectName */ public void registerMBean(final Object managedResource, final ObjectName name) { ArgumentChecker.notNull(managedResource, "managedResource"); ArgumentChecker.notNull(name, "name"); checkStatus(Status.CREATING); try { initialize0(managedResource); registerMBean0(managedResource, name); _logger.logDebug(" Registered mbean: " + managedResource); } catch (final RuntimeException ex) { _status.set(Status.FAILED); throw new RuntimeException( "Failed during registering ManagedResource: " + managedResource, ex); } }