/*****************************************************************************
* Copyright (C) PicoContainer Organization. All rights reserved. *
* ------------------------------------------------------------------------- *
* The software in this package is published under the terms of the BSD *
* style license a copy of which has been included with this distribution in *
* the LICENSE.txt file. *
* *
* Original code by *
*****************************************************************************/
package org.picocontainer.defaults;
import org.picocontainer.ComponentAdapter;
import org.picocontainer.LifecycleManager;
import org.picocontainer.MutablePicoContainer;
import org.picocontainer.Parameter;
import org.picocontainer.PicoContainer;
import org.picocontainer.PicoException;
import org.picocontainer.PicoRegistrationException;
import org.picocontainer.PicoVerificationException;
import org.picocontainer.PicoVisitor;
import org.picocontainer.Startable;
import org.picocontainer.Disposable;
import org.picocontainer.alternatives.ImmutablePicoContainer;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* <p/>
* The Standard {@link PicoContainer}/{@link MutablePicoContainer} implementation.
* Constructing a container c with a parent p container will cause c to look up components
* in p if they cannot be found inside c itself.
* </p>
* <p/>
* Using {@link Class} objects as keys to the various registerXXX() methods makes
* a subtle semantic difference:
* </p>
* <p/>
* If there are more than one registered components of the same type and one of them are
* registered with a {@link java.lang.Class} key of the corresponding type, this component
* will take precedence over other components during type resolution.
* </p>
* <p/>
* Another place where keys that are classes make a subtle difference is in
* {@link org.picocontainer.alternatives.ImplementationHidingComponentAdapter}.
* </p>
*
* @author Paul Hammant
* @author Aslak Hellesøy
* @author Jon Tirsén
* @author Thomas Heller
* @version $Revision: 1.8 $
*/
public class DefaultPicoContainer implements MutablePicoContainer, Serializable {
private Map componentKeyToAdapterCache = new HashMap();
private ComponentAdapterFactory componentAdapterFactory;
private PicoContainer parent;
private List componentAdapters = new ArrayList();
// Keeps track of instantiation order.
private List orderedComponentAdapters = new ArrayList();
private boolean started = false;
private boolean disposed = false;
private HashSet children = new HashSet();
private LifecycleManager lifecycleManager;
/**
* Creates a new container with a custom ComponentAdapterFactory and a parent container.
* <p/>
* <em>
* Important note about caching: If you intend the components to be cached, you should pass
* in a factory that creates {@link CachingComponentAdapter} instances, such as for example
* {@link CachingComponentAdapterFactory}. CachingComponentAdapterFactory can delegate to
* other ComponentAdapterFactories.
* </em>
*
* @param componentAdapterFactory the factory to use for creation of ComponentAdapters.
* @param parent the parent container (used for component dependency lookups).
* @param lifecycleManager the liftcycle manager used to handle start/stop etc.
*/
public DefaultPicoContainer(ComponentAdapterFactory componentAdapterFactory, PicoContainer parent,
LifecycleManager lifecycleManager) {
this.lifecycleManager = lifecycleManager;
if (componentAdapterFactory == null) throw new NullPointerException("componentAdapterFactory");
this.componentAdapterFactory = componentAdapterFactory;
this.parent = parent == null ? null : new ImmutablePicoContainer(parent);
}
/**
* Creates a new container with a custom ComponentAdapterFactory and a parent container.
* <p/>
* <em>
* Important note about caching: If you intend the components to be cached, you should pass
* in a factory that creates {@link CachingComponentAdapter} instances, such as for example
* {@link CachingComponentAdapterFactory}. CachingComponentAdapterFactory can delegate to
* other ComponentAdapterFactories.
* </em>
*
* @param componentAdapterFactory the factory to use for creation of ComponentAdapters.
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(ComponentAdapterFactory componentAdapterFactory, PicoContainer parent) {
this(componentAdapterFactory, parent, new DefaultLifecycleManager());
}
/**
* Creates a new container with a (caching) {@link DefaultComponentAdapterFactory}
* and a parent container.
*/
public DefaultPicoContainer(PicoContainer parent) {
this(new DefaultComponentAdapterFactory(), parent);
}
/**
* Creates a new container with a custom ComponentAdapterFactory and no parent container.
*
* @param componentAdapterFactory the ComponentAdapterFactory to use.
*/
public DefaultPicoContainer(ComponentAdapterFactory componentAdapterFactory) {
this(componentAdapterFactory, null);
}
/**
* Creates a new container with a custom LifecycleManger and no parent container.
*
* @param lifecycleManager the lifecycle manager to manage start/stop/dispose calls on the container.
*/
public DefaultPicoContainer(LifecycleManager lifecycleManager) {
this(new DefaultComponentAdapterFactory(), null, lifecycleManager);
}
/**
* Creates a new container with a (caching) {@link DefaultComponentAdapterFactory} and no parent container.
*/
public DefaultPicoContainer() {
this(new DefaultComponentAdapterFactory(), null);
}
public Collection getComponentAdapters() {
return Collections.unmodifiableList(componentAdapters);
}
public final ComponentAdapter getComponentAdapter(Object componentKey) throws AmbiguousComponentResolutionException {
ComponentAdapter adapter = (ComponentAdapter) componentKeyToAdapterCache.get(componentKey);
if (adapter == null && parent != null) {
adapter = parent.getComponentAdapter(componentKey);
}
return adapter;
}
public ComponentAdapter getComponentAdapterOfType(Class componentType) {
// See http://jira.codehaus.org/secure/ViewIssue.jspa?key=PICO-115
ComponentAdapter adapterByKey = getComponentAdapter(componentType);
if (adapterByKey != null) {
return adapterByKey;
}
List found = getComponentAdaptersOfType(componentType);
if (found.size() == 1) {
return ((ComponentAdapter) found.get(0));
} else if (found.size() == 0) {
if (parent != null) {
return parent.getComponentAdapterOfType(componentType);
} else {
return null;
}
} else {
Class[] foundClasses = new Class[found.size()];
for (int i = 0; i < foundClasses.length; i++) {
foundClasses[i] = ((ComponentAdapter) found.get(i)).getComponentImplementation();
}
throw new AmbiguousComponentResolutionException(componentType, foundClasses);
}
}
public List getComponentAdaptersOfType(Class componentType) {
if (componentType == null) {
return Collections.EMPTY_LIST;
}
List found = new ArrayList();
for (Iterator iterator = getComponentAdapters().iterator(); iterator.hasNext();) {
ComponentAdapter componentAdapter = (ComponentAdapter) iterator.next();
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation())) {
found.add(componentAdapter);
}
}
return found;
}
/**
* {@inheritDoc}
* This method can be used to override the ComponentAdapter created by the {@link ComponentAdapterFactory}
* passed to the constructor of this container.
*/
public ComponentAdapter registerComponent(ComponentAdapter componentAdapter) throws DuplicateComponentKeyRegistrationException {
Object componentKey = componentAdapter.getComponentKey();
if (componentKeyToAdapterCache.containsKey(componentKey)) {
throw new DuplicateComponentKeyRegistrationException(componentKey);
}
componentAdapters.add(componentAdapter);
componentKeyToAdapterCache.put(componentKey, componentAdapter);
return componentAdapter;
}
public ComponentAdapter unregisterComponent(Object componentKey) {
ComponentAdapter adapter = (ComponentAdapter) componentKeyToAdapterCache.remove(componentKey);
componentAdapters.remove(adapter);
orderedComponentAdapters.remove(adapter);
return adapter;
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be an {@link InstanceComponentAdapter}.
*/
public ComponentAdapter registerComponentInstance(Object component) throws PicoRegistrationException {
return registerComponentInstance(component.getClass(), component);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be an {@link InstanceComponentAdapter}.
*/
public ComponentAdapter registerComponentInstance(Object componentKey, Object componentInstance) throws PicoRegistrationException {
ComponentAdapter componentAdapter = new InstanceComponentAdapter(componentKey, componentInstance);
registerComponent(componentAdapter);
return componentAdapter;
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Class componentImplementation) throws PicoRegistrationException {
return registerComponentImplementation(componentImplementation, componentImplementation);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation) throws PicoRegistrationException {
return registerComponentImplementation(componentKey, componentImplementation, (Parameter[]) null);
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentAdapterFactory}
* passed to the container's constructor.
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation, Parameter[] parameters) throws PicoRegistrationException {
ComponentAdapter componentAdapter = componentAdapterFactory.createComponentAdapter(componentKey, componentImplementation, parameters);
registerComponent(componentAdapter);
return componentAdapter;
}
/**
* Same as {@link #registerComponentImplementation(java.lang.Object, java.lang.Class, org.picocontainer.Parameter[])}
* but with parameters as a {@link List}. Makes it possible to use with Groovy arrays (which are actually Lists).
*/
public ComponentAdapter registerComponentImplementation(Object componentKey, Class componentImplementation, List parameters) throws PicoRegistrationException {
Parameter[] parametersAsArray = (Parameter[]) parameters.toArray(new Parameter[parameters.size()]);
return registerComponentImplementation(componentKey, componentImplementation, parametersAsArray);
}
private void addOrderedComponentAdapter(ComponentAdapter componentAdapter) {
if (!orderedComponentAdapters.contains(componentAdapter)) {
orderedComponentAdapters.add(componentAdapter);
}
}
public List getComponentInstances() throws PicoException {
return getComponentInstancesOfType(Object.class);
}
public List getComponentInstancesOfType(Class componentType) throws PicoException {
if (componentType == null) {
return Collections.EMPTY_LIST;
}
Map adapterToInstanceMap = new HashMap();
for (Iterator iterator = componentAdapters.iterator(); iterator.hasNext();) {
ComponentAdapter componentAdapter = (ComponentAdapter) iterator.next();
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation())) {
Object componentInstance = getInstance(componentAdapter);
adapterToInstanceMap.put(componentAdapter, componentInstance);
// This is to ensure all are added. (Indirect dependencies will be added
// from InstantiatingComponentAdapter).
addOrderedComponentAdapter(componentAdapter);
}
}
List result = new ArrayList();
for (Iterator iterator = orderedComponentAdapters.iterator(); iterator.hasNext();) {
Object componentAdapter = iterator.next();
final Object componentInstance = adapterToInstanceMap.get(componentAdapter);
if (componentInstance != null) {
// may be null in the case of the "implicit" adapter
// representing "this".
result.add(componentInstance);
}
}
return result;
}
public Object getComponentInstance(Object componentKey) throws PicoException {
ComponentAdapter componentAdapter = getComponentAdapter(componentKey);
if (componentAdapter != null) {
return getInstance(componentAdapter);
} else {
return null;
}
}
public Object getComponentInstanceOfType(Class componentType) {
final ComponentAdapter componentAdapter = getComponentAdapterOfType(componentType);
return componentAdapter == null ? null : getInstance(componentAdapter);
}
private Object getInstance(ComponentAdapter componentAdapter) {
// check wether this is our adapter
// we need to check this to ensure up-down dependencies cannot be followed
final boolean isLocal = componentAdapters.contains(componentAdapter);
if (isLocal) {
Object instance = componentAdapter.getComponentInstance(this);
addOrderedComponentAdapter(componentAdapter);
return instance;
} else if (parent != null) {
return parent.getComponentInstance(componentAdapter.getComponentKey());
}
// TODO: decide .. exception or null?
// exceptrion: mx: +1, joehni +1
return null;
}
public PicoContainer getParent() {
return parent;
}
public ComponentAdapter unregisterComponentByInstance(Object componentInstance) {
Collection componentAdapters = getComponentAdapters();
for (Iterator iterator = componentAdapters.iterator(); iterator.hasNext();) {
ComponentAdapter componentAdapter = (ComponentAdapter) iterator.next();
if (getInstance(componentAdapter).equals(componentInstance)) {
return unregisterComponent(componentAdapter.getComponentKey());
}
}
return null;
}
/**
* @deprecated since 1.1 - Use new VerifyingVisitor().traverse(this)
*/
public void verify() throws PicoVerificationException {
new VerifyingVisitor().traverse(this);
}
/**
* Start the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Startable} will be started.
*
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void start() {
if (disposed) throw new IllegalStateException("Already disposed");
if (started) throw new IllegalStateException("Already started");
lifecycleManager.start(this);
for (Iterator iterator = children.iterator(); iterator.hasNext();) {
PicoContainer child = (PicoContainer) iterator.next();
if (child instanceof Startable) {
child.start();
}
}
started = true;
}
/**
* Stop the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Startable} will be stopped.
*
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void stop() {
if (disposed) throw new IllegalStateException("Already disposed");
if (!started) throw new IllegalStateException("Not started");
for (Iterator iterator = children.iterator(); iterator.hasNext();) {
PicoContainer child = (PicoContainer) iterator.next();
if (child instanceof Startable) {
child.stop();
}
}
lifecycleManager.stop(this);
started = false;
}
/**
* Dispose the components of this PicoContainer and all its logical child containers.
* Any component implementing the lifecycle interface {@link org.picocontainer.Disposable} will be disposed.
*
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void dispose() {
if (disposed) throw new IllegalStateException("Already disposed");
for (Iterator iterator = children.iterator(); iterator.hasNext();) {
PicoContainer child = (PicoContainer) iterator.next();
if (child instanceof Disposable) {
child.dispose();
}
}
lifecycleManager.dispose(this);
disposed = true;
}
public MutablePicoContainer makeChildContainer() {
DefaultPicoContainer pc = new DefaultPicoContainer(componentAdapterFactory, this, lifecycleManager);
addChildContainer(pc);
return pc;
}
public boolean addChildContainer(PicoContainer child) {
return children.add(child);
}
public boolean removeChildContainer(PicoContainer child) {
final boolean result = children.remove(child);
return result;
}
public void accept(PicoVisitor visitor) {
visitor.visitContainer(this);
final List componentAdapters = new ArrayList(getComponentAdapters());
for (Iterator iterator = componentAdapters.iterator(); iterator.hasNext();) {
ComponentAdapter componentAdapter = (ComponentAdapter) iterator.next();
componentAdapter.accept(visitor);
}
final List allChildren = new ArrayList(children);
for (Iterator iterator = allChildren.iterator(); iterator.hasNext();) {
PicoContainer child = (PicoContainer) iterator.next();
child.accept(visitor);
}
}
}