Registry (Apache Tomcat 8.0.15 API Documentation)

java.lang.Object
- org.apache.tomcat.util.modeler.Registry

All Implemented Interfaces:

MBeanRegistration, RegistryMBean
```
public class Registry
extends Object
implements RegistryMBean, MBeanRegistration
```
Registry for modeler MBeans. This is the main entry point into modeler. It provides methods to create and manipulate model mbeans and simplify their use. Starting with version 1.1, this is no longer a singleton and the static methods are strongly deprecated. In a container environment we can expect different applications to use different registries. This class is itself an mbean. IMPORTANT: public methods not marked with @since x.x are experimental or internal. Should not be used.

Author:

Craig R. McClanahan, Costin Manolache

Constructor Summary

Constructors
Constructor and Description

Registry()

Constructors
Constructor and Description
`Registry()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addManagedBean(ManagedBean bean)` Add a new bean metadata to the set of beans known to this registry.
`Object`	`convertValue(String type, String value)` EXPERIMENTAL Convert a string to object, based on type.
`ManagedBean`	`findManagedBean(Object bean, Class<?> beanClass, String type)` Find or load metadata.
`ManagedBean`	`findManagedBean(String name)` Find and return the managed bean definition for the specified bean name, if any; otherwise return `null`.
`int`	`getId(String domain, String name)` Return an int ID for faster access.
`MBeanServer`	`getMBeanServer()` Factory method to create (if necessary) and return our `MBeanServer` instance.
`MBeanOperationInfo`	`getMethodInfo(ObjectName oname, String opName)` Find the operation info for a method
`static Registry`	`getRegistry(Object key, Object guard)` Factory method to create (if necessary) and return our `Registry` instance.
`String`	`getType(ObjectName oname, String attName)` Get the type of an attribute of the object, from the metadata.
`void`	`invoke(List<ObjectName> mbeans, String operation, boolean failFirst)` Invoke a operation on a list of mbeans.
`List<ObjectName>`	`load(String sourceType, Object source, String param)` Experimental.
`void`	`loadDescriptors(String packageName, ClassLoader classLoader)` Lookup the component descriptor in the package and in the parent packages.
`void`	`postDeregister()`
`void`	`postRegister(Boolean registrationDone)`
`void`	`preDeregister()`
`ObjectName`	`preRegister(MBeanServer server, ObjectName name)`
`void`	`registerComponent(Object bean, ObjectName oname, String type)` Register a component XXX make it private
`void`	`registerComponent(Object bean, String oname, String type)` Register a bean by creating a modeler mbean and adding it to the MBeanServer.
`void`	`stop()` Lifecycle method - clean up the registry metadata.
`void`	`unregisterComponent(ObjectName oname)` Unregister a component.
`void`	`unregisterComponent(String oname)` Unregister a component.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Registry
```
public Registry()
```
- Method Detail
  - getRegistry
```
public static Registry getRegistry(Object key,
                   Object guard)
```
    Factory method to create (if necessary) and return our Registry instance. Use this method to obtain a Registry - all other static methods are deprecated and shouldn't be used. The current version uses a static - future versions could use the thread class loader.
    
    Parameters:
    key - Support for application isolation. If null, the context class loader will be used ( if setUseContextClassLoader is called ) or the default registry is returned.
    guard - Prevent access to the registry by untrusted components
    Since:
    
    1.1
  - stop
```
public void stop()
```
    Lifecycle method - clean up the registry metadata. Called from resetMetadata().
    
    Specified by:
    
    stop in interface RegistryMBean
    
    Since:
    
    1.1
  - registerComponent
```
public void registerComponent(Object bean,
                     String oname,
                     String type)
                       throws Exception
```
    Register a bean by creating a modeler mbean and adding it to the MBeanServer. If metadata is not loaded, we'll look up and read a file named "mbeans-descriptors.ser" or "mbeans-descriptors.xml" in the same package or parent. If the bean is an instance of DynamicMBean. it's metadata will be converted to a model mbean and we'll wrap it - so modeler services will be supported If the metadata is still not found, introspection will be used to extract it automatically. If an mbean is already registered under this name, it'll be first unregistered. If the component implements MBeanRegistration, the methods will be called. If the method has a method "setRegistry" that takes a RegistryMBean as parameter, it'll be called with the current registry.
    
    Specified by:
    
    registerComponent in interface RegistryMBean
    
    Parameters:
    bean - Object to be registered
    oname - Name used for registration
    type - The type of the mbean, as declared in mbeans-descriptors. If null, the name of the class will be used. This can be used as a hint or by subclasses.
    
    Throws:
    
    Exception
    Since:
    
    1.1
  - unregisterComponent
```
public void unregisterComponent(String oname)
```
    Unregister a component. We'll first check if it is registered, and mask all errors. This is mostly a helper.
    
    Specified by:
    
    unregisterComponent in interface RegistryMBean
    
    Parameters:
    oname -
    Since:
    
    1.1
  - invoke
```
public void invoke(List<ObjectName> mbeans,
          String operation,
          boolean failFirst)
            throws Exception
```
    Invoke a operation on a list of mbeans. Can be used to implement lifecycle operations.
    
    Specified by:
    
    invoke in interface RegistryMBean
    
    Parameters:
    mbeans - list of ObjectName on which we'll invoke the operations
    operation - Name of the operation ( init, start, stop, etc)
    failFirst - If false, exceptions will be ignored
    
    Throws:
    
    Exception
    Since:
    
    1.1
  - getId
```
public int getId(String domain,
        String name)
```
    Return an int ID for faster access. Will be used for notifications and for other operations we want to optimize.
    
    Specified by:
    
    getId in interface RegistryMBean
    
    Parameters:
    domain - Namespace
    name - Type of the notification
    
    Returns:
    An unique id for the domain:name combination
    Since:
    
    1.1
  - addManagedBean
```
public void addManagedBean(ManagedBean bean)
```
    Add a new bean metadata to the set of beans known to this registry. This is used by internal components.
    
    Parameters:
    bean - The managed bean to be added
    Since:
    
    1.0
  - findManagedBean
```
public ManagedBean findManagedBean(String name)
```
    Find and return the managed bean definition for the specified bean name, if any; otherwise return null.
    
    Parameters:
    name - Name of the managed bean to be returned. Since 1.1, both short names or the full name of the class can be used.
    Since:
    
    1.0
  - getType
```
public String getType(ObjectName oname,
             String attName)
```
    Get the type of an attribute of the object, from the metadata.
    
    Parameters:
    oname -
    attName -
    
    Returns:
    null if metadata about the attribute is not found
    Since:
    
    1.1
  - getMethodInfo
```
public MBeanOperationInfo getMethodInfo(ObjectName oname,
                               String opName)
```
    Find the operation info for a method
    
    Parameters:
    oname -
    opName -
    
    Returns:
    the operation info for the specified operation
  - unregisterComponent
```
public void unregisterComponent(ObjectName oname)
```
    Unregister a component. This is just a helper that avoids exceptions by checking if the mbean is already registered
    
    Parameters:
    oname -
  - getMBeanServer
```
public MBeanServer getMBeanServer()
```
    Factory method to create (if necessary) and return our MBeanServer instance.
  - findManagedBean
```
public ManagedBean findManagedBean(Object bean,
                          Class<?> beanClass,
                          String type)
                            throws Exception
```
    Find or load metadata.
    
    Throws:
    
    Exception
  - convertValue
```
public Object convertValue(String type,
                  String value)
```
    EXPERIMENTAL Convert a string to object, based on type. Used by several components. We could provide some pluggability. It is here to keep things consistent and avoid duplication in other tasks
    
    Parameters:
    type - Fully qualified class name of the resulting value
    value - String value to be converted
    
    Returns:
    Converted value
  - load
```
public List<ObjectName> load(String sourceType,
                    Object source,
                    String param)
                      throws Exception
```
    Experimental.
    
    Parameters:
    sourceType -
    source -
    param -
    
    Returns:
    List of descriptors
    
    Throws:
    
    Exception
  - registerComponent
```
public void registerComponent(Object bean,
                     ObjectName oname,
                     String type)
                       throws Exception
```
    Register a component XXX make it private
    
    Parameters:
    bean -
    oname -
    type -
    
    Throws:
    
    Exception
  - loadDescriptors
```
public void loadDescriptors(String packageName,
                   ClassLoader classLoader)
```
    Lookup the component descriptor in the package and in the parent packages.
    
    Parameters:
    packageName -
  - preRegister
```
public ObjectName preRegister(MBeanServer server,
                     ObjectName name)
                       throws Exception
```
    Specified by:
    
    preRegister in interface MBeanRegistration
    
    Throws:
    
    Exception
  - postRegister
```
public void postRegister(Boolean registrationDone)
```
    Specified by:
    
    postRegister in interface MBeanRegistration
  - preDeregister
```
public void preDeregister()
                   throws Exception
```
    Specified by:
    
    preDeregister in interface MBeanRegistration
    
    Throws:
    
    Exception
  - postDeregister
```
public void postDeregister()
```
    Specified by:
    
    postDeregister in interface MBeanRegistration

Class Registry

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Registry

Method Detail

getRegistry

stop

registerComponent

unregisterComponent

invoke

getId

addManagedBean

findManagedBean

getType

getMethodInfo

unregisterComponent

getMBeanServer

findManagedBean

convertValue

load

registerComponent

loadDescriptors

preRegister

postRegister

preDeregister

postDeregister