cwalltx 's Bookmarks tagged eclipse →  View Popular

The Extension Registry is a place where extension points are matched
up with extensions. An extension point is a declaration made by a
plug-in to say that it is open to being extended with new functionality
in a particular way. It is found in the plugin.xml file for the
plug-in, and it consists of:

• An extension point ID, which consists of a “namespace” and suffix. The
  namespace is usually the ID of the plugin in which the extension point
  is defined, but it need not be. This is different from an “XML namespace”.




• A human-readable name.




• An XML schema document, which defines the structure of the meta-data
  that extensions are required to supply.

An extension is the flip-side of the coin. It is a declaration by a
plug-in to say that it provides functionality to extend another
plug-in. It is also found in the plugin.xml and it specifies:

• The ID of the extension point.




• An XML node, which must comply with the schema specified by the
  extension point.

The points to take away from this are:

• extensions are declarations




• plug-ins consult extensions to create placeholders for functionality




• the functionality behind the placeholder is realized when the extension
  point definer chooses, which enables lazy loading and smaller memory usage




• extensions need not be associated with executable Java code

These are all valid questions, and the answer in each case is that it
depends on our requirements. Therefore DS provides control in the three
dimensions involved:

1. Optional vs mandatory.


2. Unary vs multiple.


3. Static vs dynamic.

Combining the first two axes gives the familar four choices of 0..1
(optional + unary), 1..1 (mandatory + unary), 1..n (mandatory +
multiple) and 0..n (optional + multiple). The third axis is less
familiar. A dependency is dynamic if it can be hot-swapped, i.e. if
service B can be supplied subtitute instances of A. Sometime this isn’t
possible; for example A might be stateful, or B may simply not be able
to handle substitution because of the way it was programmed. We say
that the dependency is static – we must destroy B and create a new
instance of it.