org.codehaus.plexus
Class DefaultPlexusContainer

java.lang.Object
  extended by org.codehaus.plexus.logging.AbstractLogEnabled
      extended by org.codehaus.plexus.DefaultPlexusContainer
All Implemented Interfaces:
LogEnabled, PlexusContainer

public class DefaultPlexusContainer
extends AbstractLogEnabled
implements PlexusContainer


Field Summary
static java.lang.String BOOTSTRAP_CONFIGURATION
           
private  java.util.Map childContainers
           
private  org.codehaus.classworlds.ClassWorld classWorld
           
private  ComponentComposerManager componentComposerManager
           
private  ComponentDiscovererManager componentDiscovererManager
           
private  ComponentFactoryManager componentFactoryManager
           
private  ComponentManagerManager componentManagerManager
           
private  ComponentRepository componentRepository
           
protected  PlexusConfiguration configuration
           
private  java.io.Reader configurationReader
           
private  DefaultContext context
           
private  org.codehaus.classworlds.ClassRealm coreRealm
           
private  java.util.Date creationDate
           
private  boolean initialized
           
private  LifecycleHandlerManager lifecycleHandlerManager
           
private  LoggerManager loggerManager
           
private  java.lang.String name
           
private  PlexusContainer parentContainer
           
private  org.codehaus.classworlds.ClassRealm plexusRealm
           
private  boolean started
           
 
Fields inherited from interface org.codehaus.plexus.PlexusContainer
ROLE
 
Constructor Summary
DefaultPlexusContainer()
           
 
Method Summary
 void addComponentDescriptor(ComponentDescriptor componentDescriptor)
           
 void addContextValue(java.lang.Object key, java.lang.Object value)
           
 void addJarRepository(java.io.File repository)
           
 void addJarResource(java.io.File jar)
           
 void composeComponent(java.lang.Object component, ComponentDescriptor componentDescriptor)
           
 PlexusContainer createChildContainer(java.lang.String name, java.util.List classpathJars, java.util.Map context)
           
 PlexusContainer createChildContainer(java.lang.String name, java.util.List classpathJars, java.util.Map context, java.util.List discoveryListeners)
           
 java.lang.Object createComponentInstance(ComponentDescriptor componentDescriptor)
           
private  ComponentManager createComponentManager(ComponentDescriptor descriptor)
           
 java.util.List discoverComponents(org.codehaus.classworlds.ClassRealm classRealm)
          TODO: Enhance the ComponentRepository so that it can take entire ComponentSetDescriptors instead of just ComponentDescriptors.
 void dispose()
           
protected  void disposeAllComponents()
           
 PlexusContainer getChildContainer(java.lang.String name)
           
 org.codehaus.classworlds.ClassWorld getClassWorld()
           
 ComponentDescriptor getComponentDescriptor(java.lang.String componentKey)
           
 java.util.List getComponentDescriptorList(java.lang.String role)
           
 java.util.Map getComponentDescriptorMap(java.lang.String role)
           
 org.codehaus.classworlds.ClassRealm getComponentRealm(java.lang.String id)
          Deprecated. Use getContainerRealm() instead.
 org.codehaus.classworlds.ClassRealm getContainerRealm()
           
 Context getContext()
           
 org.codehaus.classworlds.ClassRealm getCoreRealm()
           
 java.util.Date getCreationDate()
           
protected  java.io.Reader getInterpolationConfigurationReader(java.io.Reader reader)
           
 Logger getLogger()
           
 LoggerManager getLoggerManager()
           
 java.lang.String getName()
           
 boolean hasChildContainer(java.lang.String name)
           
 boolean hasComponent(java.lang.String componentKey)
           
 boolean hasComponent(java.lang.String role, java.lang.String roleHint)
           
 void initialize()
           
private  void initializeClassWorlds()
           
protected  void initializeConfiguration()
           
private  void initializeContext()
           
private  void initializeCoreComponents()
           
private  void initializeLoggerManager()
           
protected  void initializeName()
          Create a name for our application if one doesn't exist.
 void initializeResources()
           
private  void initializeSystemProperties()
           
 boolean isInitialized()
           
 boolean isStarted()
           
protected  void loadComponentsOnStart()
           
 java.lang.Object lookup(java.lang.String componentKey)
           
 java.lang.Object lookup(java.lang.String role, java.lang.String roleHint)
           
 java.util.List lookupList(java.lang.String role)
           
 java.util.Map lookupMap(java.lang.String role)
           
private  void processConfigurationsDirectory()
          Process any additional component configuration files that have been specified.
private  void processCoreComponentConfiguration(java.lang.String role, BasicComponentConfigurator configurator, PlexusConfiguration c)
           
 void registerComponentDiscoveryListener(ComponentDiscoveryListener listener)
           
 void registerComponentDiscoveryListeners()
           
 void release(java.lang.Object component)
           
 void releaseAll(java.util.List components)
           
 void releaseAll(java.util.Map components)
           
 void removeChildContainer(java.lang.String name)
           
 void removeComponentDiscoveryListener(ComponentDiscoveryListener listener)
           
 void resume(java.lang.Object component)
           
 void setClassWorld(org.codehaus.classworlds.ClassWorld classWorld)
           
 void setConfigurationResource(java.io.Reader configuration)
           
 void setCoreRealm(org.codehaus.classworlds.ClassRealm coreRealm)
           
 void setLoggerManager(LoggerManager loggerManager)
           
 void setName(java.lang.String name)
           
 void setParentPlexusContainer(PlexusContainer parentContainer)
           
 void start()
           
 void suspend(java.lang.Object component)
           
 
Methods inherited from class org.codehaus.plexus.logging.AbstractLogEnabled
enableLogging, setupLogger, setupLogger, setupLogger
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

parentContainer

private PlexusContainer parentContainer

loggerManager

private LoggerManager loggerManager

context

private DefaultContext context

configuration

protected PlexusConfiguration configuration

configurationReader

private java.io.Reader configurationReader

classWorld

private org.codehaus.classworlds.ClassWorld classWorld

coreRealm

private org.codehaus.classworlds.ClassRealm coreRealm

plexusRealm

private org.codehaus.classworlds.ClassRealm plexusRealm

name

private java.lang.String name

componentRepository

private ComponentRepository componentRepository

componentManagerManager

private ComponentManagerManager componentManagerManager

lifecycleHandlerManager

private LifecycleHandlerManager lifecycleHandlerManager

componentDiscovererManager

private ComponentDiscovererManager componentDiscovererManager

componentFactoryManager

private ComponentFactoryManager componentFactoryManager

componentComposerManager

private ComponentComposerManager componentComposerManager

childContainers

private java.util.Map childContainers

BOOTSTRAP_CONFIGURATION

public static final java.lang.String BOOTSTRAP_CONFIGURATION
See Also:
Constant Field Values

started

private boolean started

initialized

private boolean initialized

creationDate

private final java.util.Date creationDate
Constructor Detail

DefaultPlexusContainer

public DefaultPlexusContainer()
Method Detail

getCreationDate

public java.util.Date getCreationDate()
Specified by:
getCreationDate in interface PlexusContainer

hasChildContainer

public boolean hasChildContainer(java.lang.String name)
Specified by:
hasChildContainer in interface PlexusContainer

removeChildContainer

public void removeChildContainer(java.lang.String name)
Specified by:
removeChildContainer in interface PlexusContainer

getChildContainer

public PlexusContainer getChildContainer(java.lang.String name)
Specified by:
getChildContainer in interface PlexusContainer

createChildContainer

public PlexusContainer createChildContainer(java.lang.String name,
                                            java.util.List classpathJars,
                                            java.util.Map context)
                                     throws PlexusContainerException
Specified by:
createChildContainer in interface PlexusContainer
Throws:
PlexusContainerException

createChildContainer

public PlexusContainer createChildContainer(java.lang.String name,
                                            java.util.List classpathJars,
                                            java.util.Map context,
                                            java.util.List discoveryListeners)
                                     throws PlexusContainerException
Specified by:
createChildContainer in interface PlexusContainer
Throws:
PlexusContainerException

lookup

public java.lang.Object lookup(java.lang.String componentKey)
                        throws ComponentLookupException
Specified by:
lookup in interface PlexusContainer
Throws:
ComponentLookupException

createComponentManager

private ComponentManager createComponentManager(ComponentDescriptor descriptor)
                                         throws ComponentLookupException
Throws:
ComponentLookupException

lookupMap

public java.util.Map lookupMap(java.lang.String role)
                        throws ComponentLookupException
Specified by:
lookupMap in interface PlexusContainer
Throws:
ComponentLookupException

lookupList

public java.util.List lookupList(java.lang.String role)
                          throws ComponentLookupException
Specified by:
lookupList in interface PlexusContainer
Throws:
ComponentLookupException

lookup

public java.lang.Object lookup(java.lang.String role,
                               java.lang.String roleHint)
                        throws ComponentLookupException
Specified by:
lookup in interface PlexusContainer
Throws:
ComponentLookupException

getComponentDescriptor

public ComponentDescriptor getComponentDescriptor(java.lang.String componentKey)
Specified by:
getComponentDescriptor in interface PlexusContainer

getComponentDescriptorMap

public java.util.Map getComponentDescriptorMap(java.lang.String role)
Specified by:
getComponentDescriptorMap in interface PlexusContainer

getComponentDescriptorList

public java.util.List getComponentDescriptorList(java.lang.String role)
Specified by:
getComponentDescriptorList in interface PlexusContainer

addComponentDescriptor

public void addComponentDescriptor(ComponentDescriptor componentDescriptor)
                            throws ComponentRepositoryException
Specified by:
addComponentDescriptor in interface PlexusContainer
Throws:
ComponentRepositoryException

release

public void release(java.lang.Object component)
             throws ComponentLifecycleException
Specified by:
release in interface PlexusContainer
Throws:
ComponentLifecycleException

releaseAll

public void releaseAll(java.util.Map components)
                throws ComponentLifecycleException
Specified by:
releaseAll in interface PlexusContainer
Throws:
ComponentLifecycleException

releaseAll

public void releaseAll(java.util.List components)
                throws ComponentLifecycleException
Specified by:
releaseAll in interface PlexusContainer
Throws:
ComponentLifecycleException

hasComponent

public boolean hasComponent(java.lang.String componentKey)
Specified by:
hasComponent in interface PlexusContainer

hasComponent

public boolean hasComponent(java.lang.String role,
                            java.lang.String roleHint)
Specified by:
hasComponent in interface PlexusContainer

suspend

public void suspend(java.lang.Object component)
             throws ComponentLifecycleException
Specified by:
suspend in interface PlexusContainer
Throws:
ComponentLifecycleException

resume

public void resume(java.lang.Object component)
            throws ComponentLifecycleException
Specified by:
resume in interface PlexusContainer
Throws:
ComponentLifecycleException

getComponentRealm

public org.codehaus.classworlds.ClassRealm getComponentRealm(java.lang.String id)
Deprecated. Use getContainerRealm() instead.

Specified by:
getComponentRealm in interface PlexusContainer

isInitialized

public boolean isInitialized()
Specified by:
isInitialized in interface PlexusContainer

initialize

public void initialize()
                throws PlexusContainerException
Specified by:
initialize in interface PlexusContainer
Throws:
PlexusContainerException

registerComponentDiscoveryListeners

public void registerComponentDiscoveryListeners()
                                         throws ComponentLookupException
Throws:
ComponentLookupException

discoverComponents

public java.util.List discoverComponents(org.codehaus.classworlds.ClassRealm classRealm)
                                  throws PlexusConfigurationException,
                                         ComponentRepositoryException
TODO: Enhance the ComponentRepository so that it can take entire ComponentSetDescriptors instead of just ComponentDescriptors.

Throws:
PlexusConfigurationException
ComponentRepositoryException

isStarted

public boolean isStarted()
Specified by:
isStarted in interface PlexusContainer

start

public void start()
           throws PlexusContainerException
Specified by:
start in interface PlexusContainer
Throws:
PlexusContainerException

dispose

public void dispose()
Specified by:
dispose in interface PlexusContainer

disposeAllComponents

protected void disposeAllComponents()

setParentPlexusContainer

public void setParentPlexusContainer(PlexusContainer parentContainer)
Specified by:
setParentPlexusContainer in interface PlexusContainer

addContextValue

public void addContextValue(java.lang.Object key,
                            java.lang.Object value)
Specified by:
addContextValue in interface PlexusContainer

setConfigurationResource

public void setConfigurationResource(java.io.Reader configuration)
                              throws PlexusConfigurationResourceException
Specified by:
setConfigurationResource in interface PlexusContainer
Throws:
PlexusConfigurationResourceException
See Also:
PlexusContainer.setConfigurationResource(Reader)

loadComponentsOnStart

protected void loadComponentsOnStart()
                              throws PlexusConfigurationException,
                                     ComponentLookupException
Throws:
PlexusConfigurationException
ComponentLookupException

getName

public java.lang.String getName()

setName

public void setName(java.lang.String name)

getClassWorld

public org.codehaus.classworlds.ClassWorld getClassWorld()

setClassWorld

public void setClassWorld(org.codehaus.classworlds.ClassWorld classWorld)

getCoreRealm

public org.codehaus.classworlds.ClassRealm getCoreRealm()

setCoreRealm

public void setCoreRealm(org.codehaus.classworlds.ClassRealm coreRealm)

initializeClassWorlds

private void initializeClassWorlds()
                            throws org.codehaus.classworlds.DuplicateRealmException
Throws:
org.codehaus.classworlds.DuplicateRealmException

getContainerRealm

public org.codehaus.classworlds.ClassRealm getContainerRealm()
Specified by:
getContainerRealm in interface PlexusContainer

initializeName

protected void initializeName()
Create a name for our application if one doesn't exist.


getContext

public Context getContext()
Specified by:
getContext in interface PlexusContainer

initializeContext

private void initializeContext()

initializeConfiguration

protected void initializeConfiguration()
                                throws ConfigurationProcessingException,
                                       ConfigurationResourceNotFoundException,
                                       PlexusConfigurationException
Throws:
ConfigurationProcessingException
ConfigurationResourceNotFoundException
PlexusConfigurationException

getInterpolationConfigurationReader

protected java.io.Reader getInterpolationConfigurationReader(java.io.Reader reader)

processConfigurationsDirectory

private void processConfigurationsDirectory()
                                     throws PlexusConfigurationException
Process any additional component configuration files that have been specified. The specified directory is scanned recursively so configurations can be within nested directories to help with component organization.

Throws:
PlexusConfigurationException

initializeLoggerManager

private void initializeLoggerManager()
                              throws PlexusContainerException
Throws:
PlexusContainerException

initializeCoreComponents

private void initializeCoreComponents()
                               throws ComponentConfigurationException,
                                      ComponentRepositoryException,
                                      ContextException
Throws:
ComponentConfigurationException
ComponentRepositoryException
ContextException

processCoreComponentConfiguration

private void processCoreComponentConfiguration(java.lang.String role,
                                               BasicComponentConfigurator configurator,
                                               PlexusConfiguration c)
                                        throws ComponentConfigurationException
Throws:
ComponentConfigurationException

initializeSystemProperties

private void initializeSystemProperties()
                                 throws PlexusConfigurationException
Throws:
PlexusConfigurationException

initializeResources

public void initializeResources()
                         throws PlexusConfigurationException
Throws:
PlexusConfigurationException

addJarResource

public void addJarResource(java.io.File jar)
                    throws PlexusContainerException
Specified by:
addJarResource in interface PlexusContainer
Throws:
PlexusContainerException

addJarRepository

public void addJarRepository(java.io.File repository)
Specified by:
addJarRepository in interface PlexusContainer

getLogger

public Logger getLogger()
Specified by:
getLogger in interface PlexusContainer
Overrides:
getLogger in class AbstractLogEnabled

createComponentInstance

public java.lang.Object createComponentInstance(ComponentDescriptor componentDescriptor)
                                         throws ComponentInstantiationException,
                                                ComponentLifecycleException
Specified by:
createComponentInstance in interface PlexusContainer
Throws:
ComponentInstantiationException
ComponentLifecycleException

composeComponent

public void composeComponent(java.lang.Object component,
                             ComponentDescriptor componentDescriptor)
                      throws CompositionException,
                             UndefinedComponentComposerException
Specified by:
composeComponent in interface PlexusContainer
Throws:
CompositionException
UndefinedComponentComposerException

registerComponentDiscoveryListener

public void registerComponentDiscoveryListener(ComponentDiscoveryListener listener)
Specified by:
registerComponentDiscoveryListener in interface PlexusContainer

removeComponentDiscoveryListener

public void removeComponentDiscoveryListener(ComponentDiscoveryListener listener)
Specified by:
removeComponentDiscoveryListener in interface PlexusContainer

setLoggerManager

public void setLoggerManager(LoggerManager loggerManager)
Specified by:
setLoggerManager in interface PlexusContainer

getLoggerManager

public LoggerManager getLoggerManager()
Specified by:
getLoggerManager in interface PlexusContainer