Registry (Apache Tomcat 9.0.120 API Documentation)
Description: declaration: package: org.apache.tomcat.util.modeler, class: Registry

# Class Registry

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

All Implemented Interfaces:
  `MBeanRegistration, RegistryMBean`

Direct Known Subclasses:
  `NoDescriptorRegistry`

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. This class is itself a mbean.

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `Registry()`
  Protected constructor for Registry.

- ## Method Summary

  Modifier and Type
  Method
  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)`
  Convert a string to object, based on type.
  `static void`
  `disableRegistry()`
  Disables the registry by replacing it with a no-op implementation.
  `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
  `MBeanOperationInfo`
  `getMethodInfo(ObjectName oname, String opName, int argCount)`
  Find the operation info for a method.
  `static Registry`
  `getRegistry(Object guard)`
  Factory method to create (if necessary) and return our `Registry` instance.
  `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 an operation on a list of mbeans.
  `List<ObjectName>`
  `load(String sourceType, Object source, String param)`
  Load descriptors.
  `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, String oname, String type)`
  Register a bean by creating a modeler mbean and adding it to the MBeanServer.
  `void`
  `registerComponent(Object bean, ObjectName oname, String type)`
  Register a component
  `void`
  `stop()`
  Lifecycle method - clean up the registry metadata.
  `void`
  `unregisterComponent(String oname)`
  Unregister a component.
  `void`
  `unregisterComponent(ObjectName oname)`
  Unregister a component.

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### Registry

    protected Registry()
    Protected constructor for Registry. Use `getRegistry(Object)` to obtain an instance.

- ## Method Details

  - ### getRegistry

    public static Registry getRegistry(Object key, Object guard)
    Factory method to create (if necessary) and return our `Registry` instance.
    Parameters:
      `key` - Unused
      `guard` - Prevent access to the registry by untrusted components
    Returns:
      the registry
    Since:
      1.1

  - ### getRegistry

    public static Registry getRegistry(Object guard)
    Factory method to create (if necessary) and return our `Registry` instance.
    Parameters:
      `guard` - Prevent access to the registry by untrusted components
    Returns:
      the registry
    Throws:
      `IllegalArgumentException` - if the guard object does not allow access

  - ### disableRegistry

    public static void disableRegistry()
    Disables the registry by replacing it with a no-op implementation. After calling this method, the registry will not load or process MBean descriptors.

  - ### 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. its metadata will be converted to a model mbean, and we'll wrap it so modeler services are supported. If the metadata is still not found, introspection will be used to extract it automatically. If a 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` - if a registration error occurred
    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` - Name used for unregistration
    Since:
      1.1

  - ### invoke

    public void invoke(List<ObjectName> mbeans, String operation, boolean failFirst) throws Exception
    Invoke an 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` - Error invoking operation
    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:
      A 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.
    Returns:
      the managed bean
    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` - The bean name
      `attName` - The attribute name
    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` - The bean name
      `opName` - The operation name
    Returns:
      the operation info for the specified operation

  - ### getMethodInfo

    public MBeanOperationInfo getMethodInfo(ObjectName oname, String opName, int argCount) throws InstanceNotFoundException
    Find the operation info for a method.
    Parameters:
      `oname` - The bean name
      `opName` - The operation name
      `argCount` - The number of arguments to the method
    Returns:
      the operation info for the specified operation
    Throws:
      `InstanceNotFoundException` - If the object name is not bound to an MBean

  - ### 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` - The bean name

  - ### getMBeanServer

    public MBeanServer getMBeanServer()
    Factory method to create (if necessary) and return our `MBeanServer` instance.
    Returns:
      the MBean server

  - ### findManagedBean

    public ManagedBean findManagedBean(Object bean, Class<?> beanClass, String type) throws Exception
    Find or load metadata.
    Parameters:
      `bean` - The bean
      `beanClass` - The bean class
      `type` - The registry type
    Returns:
      the managed bean
    Throws:
      `Exception` - An error occurred

  - ### convertValue

    public Object convertValue(String type, String value)
    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
    Load descriptors.
    Parameters:
      `sourceType` - The source type
      `source` - The bean
      `param` - A type to load
    Returns:
      List of descriptors
    Throws:
      `Exception` - Error loading descriptors

  - ### registerComponent

    public void registerComponent(Object bean, ObjectName oname, String type) throws Exception
    Register a component
    Parameters:
      `bean` - The bean
      `oname` - The object name
      `type` - The registry type
    Throws:
      `Exception` - Error registering component

  - ### loadDescriptors

    public void loadDescriptors(String packageName, ClassLoader classLoader)
    Lookup the component descriptor in the package and in the parent packages.
    Parameters:
      `packageName` - The package name
      `classLoader` - The class loader

  - ### 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`