ComponentDefinition (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.beans.factory.parsing

## Interface ComponentDefinition

- All Superinterfaces:
    BeanMetadataElement
  All Known Implementing Classes:
    AbstractComponentDefinition, AdvisorComponentDefinition, AspectComponentDefinition, BeanComponentDefinition, CompositeComponentDefinition, PointcutComponentDefinition

      public interface ComponentDefinition
      extends BeanMetadataElement

  Interface that describes the logical view of a set of `BeanDefinitions` and `BeanReferences` as presented in some configuration context.

  With the introduction of `pluggable custom XML tags`, it is now possible for a single logical configuration entity, in this case an XML tag, to create multiple `BeanDefinitions` and `RuntimeBeanReferences` in order to provide more succinct configuration and greater convenience to end users. As such, it can no longer be assumed that each configuration entity (e.g. XML tag) maps to one `BeanDefinition`. For tool vendors and other users who wish to present visualization or support for configuring Spring applications it is important that there is some mechanism in place to tie the `BeanDefinitions` in the `BeanFactory` back to the configuration data in a way that has concrete meaning to the end user. As such, `NamespaceHandler` implementations are able to publish events in the form of a `ComponentDefinition` for each logical entity being configured. Third parties can then `subscribe to these events`, allowing for a user-centric view of the bean metadata.

  Each `ComponentDefinition` has a `source object` which is configuration-specific. In the case of XML-based configuration this is typically the `Node` which contains the user supplied configuration information. In addition to this, each `BeanDefinition` enclosed in a `ComponentDefinition` has its own `source object` which may point to a different, more specific, set of configuration data. Beyond this, individual pieces of bean metadata such as the `PropertyValues` may also have a source object giving an even greater level of detail. Source object extraction is handled through the `SourceExtractor` which can be customized as required.

  Whilst direct access to important `BeanReferences` is provided through `getBeanReferences()`, tools may wish to inspect all `BeanDefinitions` to gather the full set of `BeanReferences`. Implementations are required to provide all `BeanReferences` that are required to validate the configuration of the overall logical entity as well as those required to provide full user visualisation of the configuration. It is expected that certain `BeanReferences` will not be important to validation or to the user view of the configuration and as such these may be ommitted. A tool may wish to display any additional `BeanReferences` sourced through the supplied `BeanDefinitions` but this is not considered to be a typical case.

  Tools can determine the important of contained `BeanDefinitions` by checking the `role identifier`. The role is essentially a hint to the tool as to how important the configuration provider believes a `BeanDefinition` is to the end user. It is expected that tools will not display all `BeanDefinitions` for a given `ComponentDefinition` choosing instead to filter based on the role. Tools may choose to make this filtering user configurable. Particular notice should be given to the `INFRASTRUCTURE role identifier`. `BeanDefinitions` classified with this role are completely unimportant to the end user and are required only for internal implementation reasons.

  Since:
    2.0
  Author:
    Rob Harrop, Juergen Hoeller
  See Also:
    `AbstractComponentDefinition`, `CompositeComponentDefinition`, `BeanComponentDefinition`, `ReaderEventListener.componentRegistered(ComponentDefinition)`

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `BeanDefinition[]` | `getBeanDefinitions()` Return the `BeanDefinitions` that were registered to form this `ComponentDefinition`.
    `BeanReference[]` | `getBeanReferences()` Return the set of `BeanReferences` that are considered to be important to this `ComponentDefinition`.
    `String` | `getDescription()` Return a friendly description of the described component.
    `BeanDefinition[]` | `getInnerBeanDefinitions()` Return the `BeanDefinitions` that represent all relevant inner beans within this component.
    `String` | `getName()` Get the user-visible name of this `ComponentDefinition`.

    - ### Methods inherited from interface org.springframework.beans.BeanMetadataElement

      `getSource`

- - ### Method Detail

    - #### getName

          String getName()

      Get the user-visible name of this `ComponentDefinition`.

      This should link back directly to the corresponding configuration data for this component in a given context.

    - #### getDescription

          String getDescription()

      Return a friendly description of the described component.

      Implementations are encouraged to return the same value from `toString()`.

    - #### getBeanDefinitions

          BeanDefinition[] getBeanDefinitions()

      Return the `BeanDefinitions` that were registered to form this `ComponentDefinition`.

      It should be noted that a `ComponentDefinition` may well be related with other `BeanDefinitions` via `references`, however these are not included as they may be not available immediately. Important `BeanReferences` are available from `getBeanReferences()`.

      Returns:
        the array of BeanDefinitions, or an empty array if none

    - #### getInnerBeanDefinitions

          BeanDefinition[] getInnerBeanDefinitions()

      Return the `BeanDefinitions` that represent all relevant inner beans within this component.

      Other inner beans may exist within the associated `BeanDefinitions`, however these are not considered to be needed for validation or for user visualization.

      Returns:
        the array of BeanDefinitions, or an empty array if none

    - #### getBeanReferences

          BeanReference[] getBeanReferences()

      Return the set of `BeanReferences` that are considered to be important to this `ComponentDefinition`.

      Other `BeanReferences` may exist within the associated `BeanDefinitions`, however these are not considered to be needed for validation or for user visualization.

      Returns:
        the array of BeanReferences, or an empty array if none