You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@composer.apache.org by ma...@apache.org on 2008/02/04 11:44:05 UTC
svn commit: r618243 [1/2] - in
/incubator/composer/trunk/composer-site/src/site: content/
content/antipatterns/ content/help/ templates/
Author: mauro
Date: Mon Feb 4 03:43:57 2008
New Revision: 618243
URL: http://svn.apache.org/viewvc?rev=618243&view=rev
Log:
More docs cleanup.
Added:
incubator/composer/trunk/composer-site/src/site/content/command-line-arguments-container.html
- copied, changed from r618234, incubator/composer/trunk/composer-site/src/site/content/CommandLineArgumentsContainer.html
incubator/composer/trunk/composer-site/src/site/content/default-container.html
- copied, changed from r618234, incubator/composer/trunk/composer-site/src/site/content/DefaultContainer.html
incubator/composer/trunk/composer-site/src/site/content/properties-container.html
- copied, changed from r618229, incubator/composer/trunk/composer-site/src/site/content/PropertiesContainer.html
incubator/composer/trunk/composer-site/src/site/content/system-properties-container.html
- copied, changed from r618234, incubator/composer/trunk/composer-site/src/site/content/SystemPropertiesContainer.html
incubator/composer/trunk/composer-site/src/site/content/transient-container.html
- copied, changed from r618229, incubator/composer/trunk/composer-site/src/site/content/TransientContainer.html
Removed:
incubator/composer/trunk/composer-site/src/site/content/CommandLineArgumentsContainer.html
incubator/composer/trunk/composer-site/src/site/content/DefaultContainer.html
incubator/composer/trunk/composer-site/src/site/content/PropertiesContainer.html
incubator/composer/trunk/composer-site/src/site/content/SystemPropertiesContainer.html
incubator/composer/trunk/composer-site/src/site/content/TransientContainer.html
Modified:
incubator/composer/trunk/composer-site/src/site/content/ImmutableContainer.html
incubator/composer/trunk/composer-site/src/site/content/adapters.html
incubator/composer/trunk/composer-site/src/site/content/antipatterns/container-dependency-antipattern.html
incubator/composer/trunk/composer-site/src/site/content/antipatterns/propagating-dependency-antipattern.html
incubator/composer/trunk/composer-site/src/site/content/antipatterns/singleton-antipattern.html
incubator/composer/trunk/composer-site/src/site/content/antipatterns/tests-use-container-antipattern.html
incubator/composer/trunk/composer-site/src/site/content/behaviors.html
incubator/composer/trunk/composer-site/src/site/content/builder.html
incubator/composer/trunk/composer-site/src/site/content/class-naming.html
incubator/composer/trunk/composer-site/src/site/content/comparisons.html
incubator/composer/trunk/composer-site/src/site/content/component-configuration.html
incubator/composer/trunk/composer-site/src/site/content/constructor-injection.html
incubator/composer/trunk/composer-site/src/site/content/disambiguation.html
incubator/composer/trunk/composer-site/src/site/content/faq.html
incubator/composer/trunk/composer-site/src/site/content/fluent-style.html
incubator/composer/trunk/composer-site/src/site/content/goals.html
incubator/composer/trunk/composer-site/src/site/content/help/ambiguous-injectable-help.html
incubator/composer/trunk/composer-site/src/site/content/help/unprocessed-properties-help.html
incubator/composer/trunk/composer-site/src/site/content/index.html
incubator/composer/trunk/composer-site/src/site/content/injection.html
incubator/composer/trunk/composer-site/src/site/content/interception.html
incubator/composer/trunk/composer-site/src/site/content/introduction.html
incubator/composer/trunk/composer-site/src/site/content/inversion-of-control-history.html
incubator/composer/trunk/composer-site/src/site/content/inversion-of-control.html
incubator/composer/trunk/composer-site/src/site/content/lifecycle.html
incubator/composer/trunk/composer-site/src/site/content/mock-objects.html
incubator/composer/trunk/composer-site/src/site/content/monitors.html
incubator/composer/trunk/composer-site/src/site/content/news.html
incubator/composer/trunk/composer-site/src/site/content/project.html
incubator/composer/trunk/composer-site/src/site/content/properties.html
incubator/composer/trunk/composer-site/src/site/content/scopes.html
incubator/composer/trunk/composer-site/src/site/content/setter-injection.html
incubator/composer/trunk/composer-site/src/site/content/sitemap.xml
incubator/composer/trunk/composer-site/src/site/content/team.html
incubator/composer/trunk/composer-site/src/site/content/terminology.html
incubator/composer/trunk/composer-site/src/site/content/transparency.html
incubator/composer/trunk/composer-site/src/site/content/web-frameworks.html
incubator/composer/trunk/composer-site/src/site/templates/skin.html
Modified: incubator/composer/trunk/composer-site/src/site/content/ImmutableContainer.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/ImmutableContainer.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/ImmutableContainer.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/ImmutableContainer.html Mon Feb 4 03:43:57 2008
@@ -2,16 +2,16 @@
<html>
<head>
-<title>TransientApache Composer</title>
+<title>TransientContainer</title>
</head>
<body>
<p>
-ImmutableApache Composer is wapper mechanims for a MutableApache Composer. The resulting reference is not able to accept mutating method invocations by any means.
+ImmutableContainer is wapper mechanims for a MutableContainer. The resulting reference is not able to accept mutating method invocations by any means.
<p>Here is an example of use:
<div class="source">
-<pre>Apache Composer imPC = new ImmutableApache Composer(someMutableContainer);
+<pre>Container imPC = new ImmutableContainer(someMutableContainer);
-// imPC has no addComponent methods nor is it castable back to MutableApache Composer</pre>
+// imPC has no addComponent methods nor is it castable back to MutableContainer</pre>
</div>
</body>
Modified: incubator/composer/trunk/composer-site/src/site/content/adapters.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/adapters.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/adapters.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/adapters.html Mon Feb 4 03:43:57 2008
@@ -4,7 +4,7 @@
<head>
<title>Adapters</title></head>
<body>
-<p>Each time you use addComponent(..) on Apache Composer, behind the scenes a ComponentAdapter instance is set up. There is one ComponentAdapter implementation per component instance. The ComponentAdapters can be added to a container directly, or made by the ComponentFactory the container is using. Both for BehaviorFactory and InjectionFactory implementations. Its all kinda hidden from you to make Apache Composer's API appear simple.</p>
+<p>Each time you use addComponent(..) on Container, behind the scenes a ComponentAdapter instance is set up. There is one ComponentAdapter implementation per component instance. The ComponentAdapters can be added to a container directly, or made by the ComponentFactory the container is using. Both for BehaviorFactory and InjectionFactory implementations. Its all kinda hidden from you to make Container's API appear simple.</p>
<h3>Using ComponentAdapter directly. </h3>
<p>Some examples : </p>
<div class="source">
@@ -13,12 +13,12 @@
public MyAdapter() {
super(QuantumEntanglement.class, QuantumEntanglementImpl.class);
}
- public Object getComponent(Apache Composer container) {
+ public Object getComponent(Container container) {
Auditor a = container.getComponent(Auditor.class);
a.audit("QE used", new Date());
return qe;
}
- public void verify(Apache Composer container) {
+ public void verify(Container container) {
}
}
...
Modified: incubator/composer/trunk/composer-site/src/site/content/antipatterns/container-dependency-antipattern.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/antipatterns/container-dependency-antipattern.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/antipatterns/container-dependency-antipattern.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/antipatterns/container-dependency-antipattern.html Mon Feb 4 03:43:57 2008
@@ -27,7 +27,7 @@
public class BImpl implements B {
private final A a;
- BImpl(Apache Composer container) {
+ BImpl(Container container) {
a = (A) container.getComponentOfType(A.class);
/*
@@ -42,7 +42,7 @@
<div class="source">
<div>
- <pre>MutableApache Composer container = new DefaultContainer();
+ <pre>MutableContainer container = new DefaultContainer();
container.addComponent("a", AImpl.class);
container.addComponent("b", BImpl.class);
container.addComponent(container);
@@ -65,7 +65,7 @@
<div>
<h2>Causes</h2>
- <p>Not sure. Poor understanding of how Apache Composer works? Not being able to think "simple"?</p>
+ <p>Not sure. Poor understanding of how Container works? Not being able to think "simple"?</p>
</div>
<div>
<h2>What to do</h2>
@@ -85,7 +85,7 @@
}</pre>
</div>
</div>
- <p>Apache Composer will figure out that BImpl needs an A instance, and will pass in the AImpl, as this is an
+ <p>Container will figure out that BImpl needs an A instance, and will pass in the AImpl, as this is an
implementation of A.</p>
</div>
</body>
Modified: incubator/composer/trunk/composer-site/src/site/content/antipatterns/propagating-dependency-antipattern.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/antipatterns/propagating-dependency-antipattern.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/antipatterns/propagating-dependency-antipattern.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/antipatterns/propagating-dependency-antipattern.html Mon Feb 4 03:43:57 2008
@@ -110,7 +110,7 @@
<p>When [Migrating from executors to services], it can sometimes be difficult to avoid introducing a Propagating
Dependency. In these cases, the Propogating Dependency can be considered as a good first step towards
- making a set of classes good for Apache Composer. An effort should be made to complete decomposition at some stage by making a
+ making a set of classes good for Container. An effort should be made to complete decomposition at some stage by making a
series of further steps as described above.</p>
</div>
</div>
Modified: incubator/composer/trunk/composer-site/src/site/content/antipatterns/singleton-antipattern.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/antipatterns/singleton-antipattern.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/antipatterns/singleton-antipattern.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/antipatterns/singleton-antipattern.html Mon Feb 4 03:43:57 2008
@@ -17,7 +17,7 @@
that there are many transitive dependancies that are not easy to spot. Singletons cannot easily be replaced with <a
href="mock-objects.html" title="Mock Objects">Mock Objects</a> for the sake of easy unit testing.</p>
-<p>With Apache Composer we would replace this with a container <em>managed single instance</em>, possibly in a container
+<p>With Container we would replace this with a container <em>managed single instance</em>, possibly in a container
hierarchy (see <a href="introduction.html">Introduction</a>
and <a href="behaviors.html" title="Caching">Caching</a>).</p>
Modified: incubator/composer/trunk/composer-site/src/site/content/antipatterns/tests-use-container-antipattern.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/antipatterns/tests-use-container-antipattern.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/antipatterns/tests-use-container-antipattern.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/antipatterns/tests-use-container-antipattern.html Mon Feb 4 03:43:57 2008
@@ -11,7 +11,7 @@
<div>
<h2>Symptoms</h2>
- <p> A class is directly instantiating a Apache Composer and registering components within it. </p>
+ <p> A class is directly instantiating a Container and registering components within it. </p>
</div>
<div>
<h2>Causes</h2>
@@ -26,7 +26,7 @@
<div class="source">
<div>
<pre>public void testCocktailWithVodkaIsAlcoholic() {
- DefaultApache Composer container = new DefaultContainer();
+ DefaultContainer container = new DefaultContainer();
container.addComponent(Banana.class);
container.addComponent(Vanilla.class);
container.addComponent(Vodka.class);
Modified: incubator/composer/trunk/composer-site/src/site/content/behaviors.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/behaviors.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/behaviors.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/behaviors.html Mon Feb 4 03:43:57 2008
@@ -11,10 +11,10 @@
</style>
</head>
<body>
-<p>Components as managed by Apache Composer can have behaviors added
+<p>Components as managed by Container can have behaviors added
to them by the container during instantiation.</p>
-<p>Behaviors are deleivered by passing a BehaviorFactory reference into the Apache Composer instance on construction. For
+<p>Behaviors are deleivered by passing a BehaviorFactory reference into the Container instance on construction. For
the most part BehaviorFactories are completely stateless.</p>
<p>See below for details on <a href="#cns">Caching and Singletons</a>, <a href="#hasi">Implementation Hiding and Hot Swapping</a>, as well as <a href="#o">Other</a> behaviors</p>
<h3>General use</h3>
@@ -58,7 +58,7 @@
rather that a new one created each time the container is asked for that
type. <a href="http://code.google.com/p/google-guice/">Guice</a> calls
this a Singleton. After guice came out we debated this, and decided that
- we should not call this a Singleton. Another Apache Composer instance
+ we should not call this a Singleton. Another Container instance
could be manging another single instance of the same component, so it
does not fit the definition of Singleton as defined in the Design
Patterns book.</p>
@@ -255,7 +255,7 @@
<h3>Hot Swapping</h3>
<p>This builds on the <span class="style1">ASMImplementationHiding</span> behavior above, but also allows the hot swapping of component implementations during use. It has implicit caching behavior too.</p>
-<div class="source"><pre>DefaultApache Composer container = new DefaultContainer(new HotSwapping());<br />container.addComponent(Map.class, HashMap.class);<br />Map firstMap = container.getComponent(Map.class);<br />firstMap.put("foo", "bar");<br />HotSwappable hs = (HotSwappable) container.getComponentAdapter(Map.class);<br />Object oldMap = hs.getSwappable().swap(new HashMap());<br />Map secondMap = container.getComponent(Map.class);<br />secondMap.put("apple", "orange");<br />
+<div class="source"><pre>DefaultContainer container = new DefaultContainer(new HotSwapping());<br />container.addComponent(Map.class, HashMap.class);<br />Map firstMap = container.getComponent(Map.class);<br />firstMap.put("foo", "bar");<br />HotSwappable hs = (HotSwappable) container.getComponentAdapter(Map.class);<br />Object oldMap = hs.getSwappable().swap(new HashMap());<br />Map secondMap = container.getComponent(Map.class);<br />secondMap.put("apple", "orange");<br />
// first map and second map are the same
// 'foo' is not a key in the map, wereas 'apple' is</pre>
</div>
Modified: incubator/composer/trunk/composer-site/src/site/content/builder.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/builder.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/builder.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/builder.html Mon Feb 4 03:43:57 2008
@@ -5,7 +5,7 @@
<title>Building Containers</title>
</head>
<body>
-<p>Rather than new up a Apache Composer instance with the right ComponentFactory, LifecycleStategy and ComponentMonitor, your can use ContainerBuilder for conveniece. Refer to Martin's <a
+<p>Rather than new up a Container instance with the right ComponentFactory, LifecycleStategy and ComponentMonitor, your can use ContainerBuilder for conveniece. Refer to Martin's <a
href="http://www.martinfowler.com/bliki/FluentInterface.html">'Fluent
Interface'</a> article, for some of the motivation behing this class.</p>
<p>Some simple examples :</p>
@@ -61,9 +61,9 @@
.withCustomContainerComponent(new MyQuantumPhysicsConnector())
.withComponentFactory(MyQuantumPhysicsConnectionNeedingComponentBehavior.class).build();
container.addComponent(Apple.class);</pre></div>
- <p>A custom container implementation (DefaultApache Composer is the default):</p>
+ <p>A custom container implementation (DefaultContainer is the default):</p>
<div class="source">
- <pre>MyCustomApache Composer container = (MyCustomApache Composer) new ContainerBuilder().implementedBy(MyCustomApache Composer.class).build();
+ <pre>MyCustomContainer container = (MyCustomContainer) new ContainerBuilder().implementedBy(MyCustomContainer.class).build();
container.addComponent(Apple.class);</pre>
</div>
</body>
Modified: incubator/composer/trunk/composer-site/src/site/content/class-naming.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/class-naming.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/class-naming.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/class-naming.html Mon Feb 4 03:43:57 2008
@@ -5,15 +5,15 @@
<title>Class Naming</title>
</head>
<body>
-<p>Apache Composer's class naming changed substantially between 1.0 and 2.0. There are two major influences for this:</p>
+<p>Container's class naming changed substantially between 1.0 and 2.0. There are two major influences for this:</p>
<ol>
<li>Dan North's "Behavior Driven Design" agenda and his interest in Neuro Linguistic Programming (NLP)</li>
<li>Steve Yegge's technical fable : <a href="http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html">Execution in the Kingdom of Nouns</a></li>
</ol>
<p>The take away from both is that we don't have to have long classnames like <em>CachingComponentAdapterFactory</em> and <em>ImplementationHidingComponentAdapterFactory</em>, we can in fact have shorter names, that read better in their intended use:</p>
-<pre> new DefaultApache Composer(new Caching());</pre>
+<pre> new DefaultContainer(new Caching());</pre>
<p>Similarly, method names can play a part in simplicity and meaning for real situations where they are used.</p>
-<pre> new DefaultApache Composer(new Caching().wrap(new ImplementationHiding()));
+<pre> new DefaultContainer(new Caching().wrap(new ImplementationHiding()));
</pre>
<p>Caching, the class, implements an abstraction called BehaviorFactory as do many others. All BehaviorFactory implementations make implementations of Behavior like 'Cached'. Similarly 'ConstructionInjection' (and similar) make implementations of Injector like 'ConstructorInjector' (and similar). Both BehaviorFactory and InjectionFactory are extensions of ComponentFactory.</p>
<p></p>
Copied: incubator/composer/trunk/composer-site/src/site/content/command-line-arguments-container.html (from r618234, incubator/composer/trunk/composer-site/src/site/content/CommandLineArgumentsContainer.html)
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/command-line-arguments-container.html?p2=incubator/composer/trunk/composer-site/src/site/content/command-line-arguments-container.html&p1=incubator/composer/trunk/composer-site/src/site/content/CommandLineArgumentsContainer.html&r1=618234&r2=618243&rev=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/CommandLineArgumentsContainer.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/command-line-arguments-container.html Mon Feb 4 03:43:57 2008
@@ -2,12 +2,12 @@
<html>
<head>
-<title>CommandLineArgumentsApache Composer</title>
+<title>CommandLineArgumentsContainer</title>
</head>
<body>
<p>
-CommandLineArgumentsApache Composer is a special type of Apache Composer that processes the arguments passed into from the command line, and sets them up as configuration for other components.
-<p>Here is an example of how to use CommandLineArgumentsApache Composer to map command line arguments as configuration for a component, with parameter names as the bindings.
+CommandLineArgumentsContainer is a special type of Container that processes the arguments passed into from the command line, and sets them up as configuration for other components.
+<p>Here is an example of how to use CommandLineArgumentsContainer to map command line arguments as configuration for a component, with parameter names as the bindings.
<p>Consider this component:
<div class="source">
<pre>public class BigFatComponent {
@@ -29,9 +29,9 @@
<p>For automatic binding of command line arguments to parameter names of the component:</p>
<div class="source">
<pre>public static void main(String[] args) {
- Apache Composer argsContainer = new CommandLineArgumentsApache Composer(args);
+ Container argsContainer = new CommandLineArgumentsContainer(args);
- MutableApache Composer mpc = new DefaultApache Composer(argsContainer);
+ MutableContainer mpc = new DefaultContainer(argsContainer);
mpc.as(Characteristics.USE_NAMES).addComponent(BigFatComponent.class);
@@ -60,7 +60,7 @@
<li> java.sql.(Date|Time|Timestamp) </li>
<li> Any type sporting accessible constructor taking single string parameter. </li>
</ul>
- <p>CommandLineArgumentsApache Composer can be part of a tree of containers. It makes sense, of course, being more near the root of that tree.</p>
+ <p>CommandLineArgumentsContainer can be part of a tree of containers. It makes sense, of course, being more near the root of that tree.</p>
</body>
Modified: incubator/composer/trunk/composer-site/src/site/content/comparisons.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/comparisons.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/comparisons.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/comparisons.html Mon Feb 4 03:43:57 2008
@@ -11,14 +11,14 @@
<div>
<div>
<h2>Overview</h2>
- <p>This document aims to compare Apache Composer to other IoC containers, both lightweight and not.</p>
+ <p>This document aims to compare Container to other IoC containers, both lightweight and not.</p>
<p>There are a number of published API specifications since Java was initially released that proport to be container/component designs. We discuss then here, suggesting there are goals that some have met, and some not. This may help you make better design choices for your own components.</p>
</div>
<div>
<h2>IoC Containers</h2>
<div>
<h3>Spring Framework</h3>
- <p>The <a href="http://www.springframework.org/">Spring Framework</a> is a J2EE framework. As such, <a href="injection.html" title="Dependency Injection">Dependency Injection</a> and <a href="lifecycle.html" title="lifecycle">Lifecycle</a> is only one of its concerns. Apache Composer, on the other hand, is concerned only with <a href="injection.html" title="Dependency Injection">Dependency Injection</a>, configuration and <a href="lifecycle.html" title="lifecycle">Lifecycle</a>.</p>
+ <p>The <a href="http://www.springframework.org/">Spring Framework</a> is a J2EE framework. As such, <a href="injection.html" title="Dependency Injection">Dependency Injection</a> and <a href="lifecycle.html" title="lifecycle">Lifecycle</a> is only one of its concerns. Container, on the other hand, is concerned only with <a href="injection.html" title="Dependency Injection">Dependency Injection</a>, configuration and <a href="lifecycle.html" title="lifecycle">Lifecycle</a>.</p>
</div>
<div>
<h3>Apache Avalon and its containers</h3>
@@ -29,7 +29,7 @@
<tbody>
<tr>
<th> Avalon Interface </th>
- <th> Apache Composer equivalent </th>
+ <th> Container equivalent </th>
</tr>
<tr>
<td> LogEnabled </td>
@@ -132,18 +132,18 @@
<div>
<h3>Enterprise Java Beans</h3>
<p>Clearly Entity and Session beans run inside a container. The API is well defined, and to varying degrees of success one can deploy EJB appllications to WebLogic, WebSphere, Orion and JBoss etc. For assembly and configuration, there is high use of element-normal XML . There are some mandated parent objects and interfaces for various to extend and/or implement. Resolution is done by the components themselves via JNDI more often than not.</p>
- <p>Apache Composer Components are simpler in they they do not force an extensive XML markup, nor require the implementing of certaing interfaces or extening base classes. Quite importantly the relationship between factory (home), implementation (bean) and interface (remote) parts is much more real in Apache Composer-style components. EJB 2.0 components are nearly impossible to unit-test without much effort.</p>
+ <p>Container Components are simpler in they they do not force an extensive XML markup, nor require the implementing of certaing interfaces or extening base classes. Quite importantly the relationship between factory (home), implementation (bean) and interface (remote) parts is much more real in Container-style components. EJB 2.0 components are nearly impossible to unit-test without much effort.</p>
<p>With the advent of EJB 3.0 (which the our team directly influenced), things became easier for EJB developers. Annotations were used to mark fields, and methods for injection. Strangely constructors were not eligible for injection. It was reported back to the our team that it was felt that the J2EE container makers would not find it easy making multi-argument constructor injection a reality.</p>
</div>
<div>
<h3>Servlets</h3>
<p>Not so obvious - Servlets are contained by a servlet container. They are generally bundled with (or replaced by) value added propositions like JSP, but it is still a container/component design. High use of XML for assembly and configuration. Servlets have no concept of parent container or the conatainer above that (sometimes EJB) and its provision of components, which is very unfortunate. Servlets have a number of interfaces to honor, none of which is too malignent. Servlets typically deal with external (or parent) components via RMI or JNDI. In more recent releases of EJB, local interfaces rather than RMI may be the mechanism for connection the parent components. WebLogic have always provided an optimizing mechanism for this interoperation</p>
- <p>As with EJB, Apache Composer Components are far simpler. This is probably because they offer no web experience, without an extension. Servlets again are not that unit-testable.</p>
+ <p>As with EJB, Container Components are far simpler. This is probably because they offer no web experience, without an extension. Servlets again are not that unit-testable.</p>
</div>
<div>
<h3></a>Applets</h3>
<p>Applets, though presently not so often used, are a good example of Container/Component separations. There is very little XML in use by Applets. Configuration is typically delivered in applet tags in HTML. Applets are granted some access to the parent container, the brower, and its DOM model for pages and other applets. There very little standardisation for Browser as a container.</p>
- <p>As with EJB, Apache Composer Components are far simpler. Applets are unit-testable but with a little effort. Complex DOM interoperation is impossible under unit testing.</p>
+ <p>As with EJB, Container Components are far simpler. Applets are unit-testable but with a little effort. Complex DOM interoperation is impossible under unit testing.</p>
</div>
<div>
<h3>Mainable (Not actually a container)</h3>
Modified: incubator/composer/trunk/composer-site/src/site/content/component-configuration.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/component-configuration.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/component-configuration.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/component-configuration.html Mon Feb 4 03:43:57 2008
@@ -7,11 +7,11 @@
<div>
<h2>Choices</h2>
<p>In true IoC style, configuration for a component is pushed into it. </p>
-<p>With Apache Composer, there are a few ways to do this:</p>
+<p>With Container, there are a few ways to do this:</p>
<ul>
<li>Design a class to hold the configuration and have getters on it to allow depending components to access configuration.</li>
<li>Manually set the configuration for components as you add them to a container</li>
- <li>Leverage the fact that Apache Composer can pick up on named components </li>
+ <li>Leverage the fact that Container can pick up on named components </li>
</ul>
<h3>Configuration Object</h3>
<div class="source">
@@ -80,21 +80,21 @@
System.out.println("bfc: " + bfc.toString());
// Prints .. "bfg: URL=http://foo.com/spelling.wsdl, timeout=120"</pre>
</div>
- <p>This feature of Apache Composer relies on the a non-JDK mechanism of <strong>accessing parameter names for methods and constructors</strong>. In this case named parameters spellingWebServiceURL and timeout.</p>
+ <p>This feature of Container relies on the a non-JDK mechanism of <strong>accessing parameter names for methods and constructors</strong>. In this case named parameters spellingWebServiceURL and timeout.</p>
<p>There are two ways for this to work: </p>
<ul>
<li>relying on the fact that your component classes have debug info compiled into them. </li>
<li>post-processing component classes with <a href="http://paranamer.codehaus.org/">Paranamer</a> before placing them in their jar </li>
</ul>
- <p>If the parameter name information cannot be accessed at runtime by Apache Composer, then Apache Composer will be unable to differentiate between potential injectable classes of the same type and throws an exception that suggests that there is an ambiguity.</p>
+ <p>If the parameter name information cannot be accessed at runtime by Container, then Container will be unable to differentiate between potential injectable classes of the same type and throws an exception that suggests that there is an ambiguity.</p>
<p>This is <strong>not</strong> a global variable facility. Its scoped with the container in question and its child containers.</p>
</div>
<h2>Taking configuration from the elsewhere</h2>
<p>Configuration can also be bound to components with :</p>
<blockquote>
- <p><a href="CommandLineArgumentsApache Composer.html">CommandLineArgumentsApache Composer</a></p>
- <p><a href="PropertiesApache Composer.html">PropertiesApache Composer</a></p>
- <p><a href="SystemPropertiesApache Composer.html">SystemPropertiesApache Composer</a></p>
+ <p<a href="command-line-arguments-container.html">Command Line Arguments Container</a></p>
+ <p><a href="properties-container.html">Properties Container</a></p>
+ <p><a href="system-properties-container.html">System Properties Container</a></p>
</blockquote>
</body>
</html>
Modified: incubator/composer/trunk/composer-site/src/site/content/constructor-injection.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/constructor-injection.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/constructor-injection.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/constructor-injection.html Mon Feb 4 03:43:57 2008
@@ -25,7 +25,7 @@
Injection</a>
in more detail.<br />
<br />
- <img class="emoticon" src="http://docs.codehaus.org/images/icons/emoticons/information.gif" alt="" align="middle" border="0" height="16" width="16" /> Apache Composer also supports <a href="setter-injection.html" title="Setter Injection">Setter Injection</a>.</p>
+ <img class="emoticon" src="http://docs.codehaus.org/images/icons/emoticons/information.gif" alt="" align="middle" border="0" height="16" width="16" /> Container also supports <a href="setter-injection.html" title="Setter Injection">Setter Injection</a>.</p>
<h2>Origin</h2>
@@ -43,7 +43,7 @@
<pre>public class Shop {<br /> private final StockManager stockManager;<br /> private final String shopZipCode;<br /> public Shop(StockManager stockManager, String shopZipCode) {<br /> this.stockManager = stockManager;<br /> this.shopZipCode = shopZipCode;<br /> }<br /> }</pre>
</div>
<p>Note, for this there is no need to declare needs in any other way. No interfaces, no doclet tags, no external
- XML. Just your simple component(s) and Apache Composer. No need for post assembly/config initialization either. If
+ XML. Just your simple component(s) and Container. No need for post assembly/config initialization either. If
it is constructed (not withstanding some asserts on nulls) it has its needs satisfied. Components need not be
interface/implementation separated. This is the coder's choice.</p>
@@ -63,7 +63,7 @@
<h2>Container support
</h2>
-<p>Apache Composer was the first lightweight container to support and popularize this for of dependency injection.
+<p>Container was the first lightweight container to support and popularize this for of dependency injection.
Spring Framework has been retrofitted with constructor injection capability, but its primary focus is still
setter injection. Even the once heavyweight technologies like Avalon and OSGi moved towards constructor
injection.</p>
Copied: incubator/composer/trunk/composer-site/src/site/content/default-container.html (from r618234, incubator/composer/trunk/composer-site/src/site/content/DefaultContainer.html)
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/default-container.html?p2=incubator/composer/trunk/composer-site/src/site/content/default-container.html&p1=incubator/composer/trunk/composer-site/src/site/content/DefaultContainer.html&r1=618234&r2=618243&rev=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/DefaultContainer.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/default-container.html Mon Feb 4 03:43:57 2008
@@ -2,16 +2,16 @@
<html>
<head>
-<title>DefaultApache Composer</title>
+<title>DefaultContainer</title>
</head>
<body>
<p>
-DefaultApache Composer is the main workhorse container.
+DefaultContainer is the main workhorse container.
<p>Here is an example of use:
<div class="source">
-<pre>DefaultApache Composer dpc = new DefaultContainer();
-dpc.addComponent(Foo.class, FooImpl.class);
-Foo foo = dpc.getComponent(Foo.class)</pre>
+<pre>DefaultContainer container = new DefaultContainer();
+container.addComponent(Foo.class, FooImpl.class);
+Foo foo = container.getComponent(Foo.class)</pre>
</div>
<p>Parameters in its constructors can be:</p>
<ul>
Modified: incubator/composer/trunk/composer-site/src/site/content/disambiguation.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/disambiguation.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/disambiguation.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/disambiguation.html Mon Feb 4 03:43:57 2008
@@ -9,10 +9,10 @@
<h2>Overview</h2>
You may have a component that has a dependency on something that the
container could ordinarily satisfy more than one. By default,
-when Apache Composer is presented with such a situation, it will throw an
+when Container is presented with such a situation, it will throw an
exception suggesting the depency resolution is ambiguous.
<h2>Disambiguation using parameter names<span style="text-decoration: underline;"></span></h2>
-With Apache Composer 2.0 we are able to leverage the parameter names of
+With Container 2.0 we are able to leverage the parameter names of
constructors and methods in order to remove the ambiguity on
dependancies.<br />
<div class="source">
@@ -29,14 +29,14 @@
Access to parameter names was dropped from JDK 6.0 and it is uncertain
whether it will be added as a feature in another release, so
-Apache Composer relies on another open source library called <a href="http://paranamer.codehaus.org">Paranamer</a>,
+Container relies on another open source library called <a href="http://paranamer.codehaus.org">Paranamer</a>,
without requiring a dependency on its Jar. In other words,
-Apache Composer has the same classes from Paranamer in its jar.<br />
+Container has the same classes from Paranamer in its jar.<br />
<br />
-See <a href="CommandLineArgumentsApache Composer.html">CommandLineArgumentsApache Composer</a>,
-<a href="PropertiesApache Composer.html">PropertiesApache Composer</a>
-and <a href="SystemPropertiesApache Composer.html">SystemPropertiesApache Composer</a>
-for implementations of Apache Composer that set up components for
+See <a href="command-line-arguments-container.html">Command Line Arguments Container</a>,
+<a href="properties-container.html">Properties Container</a>
+and <a href="system-properties-container.html">System Properties Container</a>
+for implementations of Container that set up components for
subsequent parameter name binding.<br />
<br />
Page <a href="component-configuration.html">component-configuration</a>
@@ -54,7 +54,7 @@
<pre>@Retention(RetentionPolicy.RUNTIME)<br />@Target({ElementType.FIELD, ElementType.PARAMETER})<br />@Bind<br />public static @interface WorkingDayStockManager {}<br /><br />@Retention(RetentionPolicy.RUNTIME)<br />@Target({ElementType.FIELD, ElementType.PARAMETER})<br />@Bind<br />public static @interface AfterHoursStockManager {}<br /><br />public class Store {<br /> public Store(@WorkingDayStockManager StockManager workingDayStockManager, <br /> @AfterHoursStockManager StockManager afterHoursStockManager) {<br /> // etc<br /> }<br />}</pre>
</div>
</div>
-Making Apache Composer leverage binding annotations if present is
+Making Container leverage binding annotations if present is
automatic.<br /><br />Biniding
annotations specified for constructor parameters (as shown above),
method injection parameters as well as field injection.<br />
Modified: incubator/composer/trunk/composer-site/src/site/content/faq.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/faq.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/faq.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/faq.html Mon Feb 4 03:43:57 2008
@@ -7,13 +7,13 @@
<h3 class="headerstyle">
<table style="width: 100%; padding-right: 2mm">
<tr>
- <td align="left" valign="middle">Why Apache Composer 2.0?</td>
+ <td align="left" valign="middle">Why Container 2.0?</td>
</tr>
</table>
</h3>
<div>
- <p>First EJB 3.0 then Google Guice seemed to copy the ideas from Apache Composer, adding some more value. EJB 3.0 ommitted the essential Constructor Injection, and Guice went far to far down a annotations road. Soon after Guice, even the Spring Framework team decided to do things the direct way with 'JavaConfig'.</p>
- <p>So Apache Composer 1.x was refactored (not rewritten) into Apache Composer 2.0. All the unit tests were kept, and excerise took hundreds of commits, but the team is pleased with the result.</p>
+ <p>First EJB 3.0 then Google Guice seemed to copy the ideas from Container, adding some more value. EJB 3.0 ommitted the essential Constructor Injection, and Guice went far to far down a annotations road. Soon after Guice, even the Spring Framework team decided to do things the direct way with 'JavaConfig'.</p>
+ <p>So Container 1.x was refactored (not rewritten) into Container 2.0. All the unit tests were kept, and excerise took hundreds of commits, but the team is pleased with the result.</p>
</div>
<h3 class="headerstyle">
<table style="width: 100%; padding-right: 2mm">
@@ -49,36 +49,36 @@
<h3 class="headerstyle">
<table style="width: 100%; padding-right: 2mm">
<tr>
- <td align="left" valign="middle">How does Apache Composer decide what constructor to use?</td>
+ <td align="left" valign="middle">How does Container decide what constructor to use?</td>
</tr>
</table>
</h3>
<div>
- <p>Apache Composer will instantiate a given component using the "greediest" satisfiable constructor. By greedy, we mean the constructor that takes the most parameters. By satisfiable, we mean constructors where all arguments can be satisfied by other registered components.</p>
+ <p>Container will instantiate a given component using the "greediest" satisfiable constructor. By greedy, we mean the constructor that takes the most parameters. By satisfiable, we mean constructors where all arguments can be satisfied by other registered components.</p>
<p>If you register a component with no satisfiable constructors, or two or more ambiguous "largest" constructors, a RuntimeException will be thrown when you ask for the component instance.</p>
<p>We recommend for most components, you use only one constructor, although this is by no means a requirement.</p>
</div>
<h3 class="headerstyle">
<table style="width: 100%; padding-right: 2mm">
<tr>
- <td align="left" valign="middle">How does Apache Composer compare to EJB containers?</td>
+ <td align="left" valign="middle">How does Container compare to EJB containers?</td>
</tr>
</table>
</h3>
<div>
- <p>Oh blimey, it is rather different. EJB has loads of things you must extend, implement, provide and throw. It is also not an IoC design. It is close in that components are managed by a container, but the cumbersome and static nature of the JNDI lookups ensure that it is not actually IoC. Apache Composer is not a superset of EJB though, as it provides no remoting capability (but NanoContainer will). At least the Apache Composer compatible components hosted in this project do not.</p>
+ <p>Oh blimey, it is rather different. EJB has loads of things you must extend, implement, provide and throw. It is also not an IoC design. It is close in that components are managed by a container, but the cumbersome and static nature of the JNDI lookups ensure that it is not actually IoC. Container is not a superset of EJB though, as it provides no remoting capability (but NanoContainer will). At least the Container compatible components hosted in this project do not.</p>
</div>
<h3 class="headerstyle" >
<table style="width: 100%; padding-right: 2mm">
<tr>
- <td align="left" valign="middle">How does Apache Composer decide what constructor to use?</td>
+ <td align="left" valign="middle">How does Container decide what constructor to use?</td>
</tr>
</table>
</h3>
<div>
- <p>Apache Composer will instantiate a given component using the "greediest" satisfiable constructor. By greedy, we mean the constructor that takes the most parameters. By satisfiable, we mean constructors where all arguments can be satisfied by other registered components.</p>
+ <p>Container will instantiate a given component using the "greediest" satisfiable constructor. By greedy, we mean the constructor that takes the most parameters. By satisfiable, we mean constructors where all arguments can be satisfied by other registered components.</p>
<p>If you register a component with no satisfiable constructors, or two or more ambiguous "largest" constructors, a RuntimeException will be thrown when you ask for the component instance.</p>
- <p>We recommend, for the sake of predictablility, that Apache Composer compatible components use only one constructor, although this is by no means a requirement.</p>
+ <p>We recommend, for the sake of predictablility, that Container compatible components use only one constructor, although this is by no means a requirement.</p>
</div>
<h3 class="headerstyle" >
<table style="width: 100%; padding-right: 2mm">
@@ -88,7 +88,7 @@
</table>
</h3>
<div>
- <p>Apache Composer will look for the greediest constructor of your component. But if your component's constructor depends on primitive types you may set the values explicitly.</p>
+ <p>Container will look for the greediest constructor of your component. But if your component's constructor depends on primitive types you may set the values explicitly.</p>
<div class="source">
<div>
<pre>public interface ThreadPool {
@@ -107,7 +107,7 @@
<p>In this case you can set the parameters at registration time:</p>
<div class="source">
<div>
- <pre>DefaultApache Composer container = new DefaultContainer();
+ <pre>DefaultContainer container = new DefaultContainer();
container.addComponent(ThreadPool.class, DefaultThreadPool.class);
container.addComponent(MyComp.class, MyComp.class, new Parameters[] {
new ComponentParameter(),
@@ -116,18 +116,18 @@
MyComp myComp = (MyComp)container.getInstance(MyComp.class);</pre>
</div>
</div>
- <p>Use ConstantParameter to set constant values and the ComponentParameter to let Apache Composer resolve the dependency.</p>
+ <p>Use ConstantParameter to set constant values and the ComponentParameter to let Container resolve the dependency.</p>
</div>
<h3 class="headerstyle" >
<table style="width: 100%; padding-right: 2mm">
<tr>
- <td align="left" valign="middle">When should I use Apache Composer?</td>
+ <td align="left" valign="middle">When should I use Container?</td>
</tr>
</table>
</h3>
<div>
<p><br />
- We recommend using Apache Composer when your application consists of many different classes (components) that are related to each other. Instantiating and lacing/connecting a lot of objects can be difficult task.</p>
+ We recommend using Container when your application consists of many different classes (components) that are related to each other. Instantiating and lacing/connecting a lot of objects can be difficult task.</p>
</div>
<h3 class="headerstyle" >
<table style="width: 100%; padding-right: 2mm">
@@ -143,7 +143,7 @@
design. One, perhaps, that considers the so-designed component as more
important that the container.</p>
<p>When we set out to do this in 2003, there was nothing equivalent
-to Apache Composer (xContainer originally). XWork, that underpinned
+to Container (xContainer originally). XWork, that underpinned
WebWork2 was a general/embeddable Setter Dependency Injection framework,
but not well known. The Spring Framework started in the same timescale,
and we were talking to its authors before Martin Fowlers Dependency
@@ -175,7 +175,7 @@
</table>
</h3>
<div>
- <p>We could compile Apache Composer against Guice.jar and leverage the @Inject method with a new InjectionFactory (and probably will). The problem is that there is no easy way to use an annotation without having its class in the classpath. There's no easy 'transparent' solution for this. </p>
+ <p>We could compile Container against Guice.jar and leverage the @Inject method with a new InjectionFactory (and probably will). The problem is that there is no easy way to use an annotation without having its class in the classpath. There's no easy 'transparent' solution for this. </p>
<p>Things fail silently if the jar is missing, unless the annotation is used - then it fails noisily. Meaning, the mere declaration of an annotation on a component is not enough to cause a ClassNotFoundException on load, if its not used:</p>
<div class="source"><pre>@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
Modified: incubator/composer/trunk/composer-site/src/site/content/fluent-style.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/fluent-style.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/fluent-style.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/fluent-style.html Mon Feb 4 03:43:57 2008
@@ -5,7 +5,7 @@
<title>Fluent Stype</title>
</head>
<body>
-<p>Apache Composer allows for a very fluent style of use. Refer to Martin's <a
+<p>Container allows for a very fluent style of use. Refer to Martin's <a
href="http://www.martinfowler.com/bliki/FluentInterface.html">'Fluent
Interface'</a> article.</p>
<p>A simple example :</p>
Modified: incubator/composer/trunk/composer-site/src/site/content/goals.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/goals.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/goals.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/goals.html Mon Feb 4 03:43:57 2008
@@ -5,7 +5,7 @@
<title>Our Goals</title>
</head>
<body>
-<p>Apache Composer's core was designed with some goals in mind:</p>
+<p>Container's core was designed with some goals in mind:</p>
<ul>
<li>No mandatory dependencies.</li>
<li>No logging built in (we have a Monitor interface and implementations for Commons-Logging and Log4J etc)</li>
@@ -13,7 +13,7 @@
<li>Small jar size.</li>
<li>Embeddable by design (no main method entry point)</li>
</ul>
-<p>If someone has a need for Apache Composer that we did not originally envision, or a feature that could be imlemented, we will try to accomodate it. The principle of Lowest Common Denominator (LCD) allows us for Apache Composer itself, to keep things small, while allowing extensions to deliver the larger visions. Thus, meta-data, dependancies, mainable are all OK for related extensions of Apache Composer.</p>
+<p>If someone has a need for Container that we did not originally envision, or a feature that could be imlemented, we will try to accomodate it. The principle of Lowest Common Denominator (LCD) allows us for Container itself, to keep things small, while allowing extensions to deliver the larger visions. Thus, meta-data, dependancies, mainable are all OK for related extensions of Container.</p>
<p> </p>
<p> </p>
<p> </p>
Modified: incubator/composer/trunk/composer-site/src/site/content/help/ambiguous-injectable-help.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/help/ambiguous-injectable-help.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/help/ambiguous-injectable-help.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/help/ambiguous-injectable-help.html Mon Feb 4 03:43:57 2008
@@ -4,7 +4,7 @@
<head>
<title>Ambiguous Injectable</title></head>
<body>
-<p>Apache Composer tries to determine what to inject into the constructor of each component as it instantiates (or setters/fields for other injection types). Sometimes there can be two or more classes that could equally satisfy a constructor: </p>
+<p>Container tries to determine what to inject into the constructor of each component as it instantiates (or setters/fields for other injection types). Sometimes there can be two or more classes that could equally satisfy a constructor: </p>
<div class="source">
<pre>container.add(new Apple("Braeburn"));
container.add(new Apple("Granny Smith"));
@@ -13,7 +13,7 @@
</pre>
</div>
-<p>The best advice is don't setup Apache Composer in a way that would allow ambiguities (just put in one Apple in the case above).</p>
+<p>The best advice is don't setup Container in a way that would allow ambiguities (just put in one Apple in the case above).</p>
<p>An alternative strategy would be to use custom parameters (TODO)</p>
<p>One more strategy would be to use names parameters </p>
<div class="source">
@@ -34,13 +34,13 @@
Pie pie = container.getComponent(Pie.class); // OK this time.
</pre>
</div>
-<p>To use names Parameters, you are going to need Paranamer 1.0 (or above) in the classpath, as well as ASM 3.0 (or above). If you are expecting Apache Composer to work based on parameter names, but its not doing so, it is most likely that you do not have paranamer-1.0.jar in the classpath. See <a href="http://repository.codehaus.org/com/thoughtworks/paranamer/paranamer/">http://repository.codehaus.org/com/thoughtworks/paranamer/paranamer/</a> for versions of paranamer. Also <a href="http://maven.objectweb.org/maven2/asm/asm/">http://maven.objectweb.org/maven2/asm/asm/</a> for the ASM jar.</p>
+<p>To use names Parameters, you are going to need Paranamer 1.0 (or above) in the classpath, as well as ASM 3.0 (or above). If you are expecting Container to work based on parameter names, but its not doing so, it is most likely that you do not have paranamer-1.0.jar in the classpath. See <a href="http://repository.codehaus.org/com/thoughtworks/paranamer/paranamer/">http://repository.codehaus.org/com/thoughtworks/paranamer/paranamer/</a> for versions of paranamer. Also <a href="http://maven.objectweb.org/maven2/asm/asm/">http://maven.objectweb.org/maven2/asm/asm/</a> for the ASM jar.</p>
<p>You also have to make a decision as to when parameter name data is made. There are two choices for this:</p>
<ol>
<li>At runtime</li>
<li>At build time </li>
</ol>
-<p>When at runtime, Apache Composer will need to be accompanied by ASM and Paranamer in the classpath. You will also need to compile your Java classes with debug information.</p>
+<p>When at runtime, Container will need to be accompanied by ASM and Paranamer in the classpath. You will also need to compile your Java classes with debug information.</p>
<p>When at build time, you will need to use and Ant or Maven fragment to post-process the compiled classes for your app to add the paramaeter name data. At runtime, neither Paranamer nor ASM will be needed. See <a href="http://paranamer.codehaus.org/">http://paranamer.codehaus.org/</a> - specifically the quick start section pertinent to Ant and Maven. </p>
<p> </p>
<p> </p>
Modified: incubator/composer/trunk/composer-site/src/site/content/help/unprocessed-properties-help.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/help/unprocessed-properties-help.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/help/unprocessed-properties-help.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/help/unprocessed-properties-help.html Mon Feb 4 03:43:57 2008
@@ -12,15 +12,15 @@
</div>
But with a custom ComponentFactory, it may not:
<div class="source">
- <pre>container = new DefaultApache Composer(new MyComponentFactory);
+ <pre>container = new DefaultContainer(new MyComponentFactory);
container.as(HIDE_IMPL).addComponent(Apple.class); // fails with CompositionException</pre>
</div>
The trick is (in this case) to make sure that the right chain of component factories are setup:
<div class="source">
- <pre>container = new DefaultApache Composer(new MyComponentFactory().wrap(new AdaptiveBehaviorFactory()));
+ <pre>container = new DefaultContainer(new MyComponentFactory().wrap(new AdaptiveBehaviorFactory()));
container.as(HIDE_IMPL).addComponent(Apple.class); // fails with CompositionException</pre>
</div>
-<p>A component may have many properties as it is added to the container. As each is processed, it is removed from the set. If there are any left after the component has been added the behavior or action that the property suggests has not been setup. Thus a CompositionException being thrown warning of unprocessed properties only happens one or more properties are left - whether they are Apache Composer's own properties or custom ones</p>
+<p>A component may have many properties as it is added to the container. As each is processed, it is removed from the set. If there are any left after the component has been added the behavior or action that the property suggests has not been setup. Thus a CompositionException being thrown warning of unprocessed properties only happens one or more properties are left - whether they are Container's own properties or custom ones</p>
</body>
</html>
Modified: incubator/composer/trunk/composer-site/src/site/content/index.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/index.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/index.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/index.html Mon Feb 4 03:43:57 2008
@@ -7,9 +7,9 @@
<body>
-<h2>What is Apache Composer?</h2>
+<h2>What is Container?</h2>
-<p>Apache Composer is a highly embeddable full service Inversion of Control (IoC) container
+<p>Container is a highly embeddable full service Inversion of Control (IoC) container
for components honour the Dependency Injection pattern.</p>
<p>You could use it as a lightweight alternative to Sun's J2EE patterns for web applications or general solutions. </p>
<p>What is Dependency Injection? Martin Fowler has a good <a href="http://www.martinfowler.com/articles/injection.html">article</a> from 2003, but here is another view: It is a good design pattern that, for large enterprise applications, facilitates: </p>
@@ -32,8 +32,8 @@
<li>suffers repeated allegations of being unable to be developed without complete rewrite </li>
</ul>
<p>Despite it being very compact in size (the core is ~128K and it
-has no mandatory dependencies outside the JDK), Apache Composer supports different dependency injection types (Constructor, Setter, Annotated Field and Method) and offers multiple lifecycle and monitoring strategies.</p>
-<p>Apache Composer has originally been implemented in Java but is also
+has no mandatory dependencies outside the JDK), Container supports different dependency injection types (Constructor, Setter, Annotated Field and Method) and offers multiple lifecycle and monitoring strategies.</p>
+<p>Container has originally been implemented in Java but is also
available for other platforms and languages. These are detailed <a href="http://docs.codehaus.org/display/PICO/Ports">here</a>.</p>
<div class="section">
<h3>Getting Started</h3>
Modified: incubator/composer/trunk/composer-site/src/site/content/injection.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/injection.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/injection.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/injection.html Mon Feb 4 03:43:57 2008
@@ -11,9 +11,9 @@
<div class="source">
<pre>public class Apple {<br /> private final Orange orange;<br /> private final Pear pear;<br /> private final Banana banana;<br /><br /> public Apple(Orange orange, Pear pear, Banana banana) {<br /> this.orange = orange;<br /> this.pear = pear;<br /> this.banana = banana;<br /> }<br /><br /> // methods<br />}</pre></div>
<p>
-The Apache Composer team recomends CDI over other types. There is no need
+The Container team recomends CDI over other types. There is no need
to mark up the constructor with an annotation. Having more than one
-constructor is OK too, as Apache Composer will try to use the one with
+constructor is OK too, as Container will try to use the one with
the most arguments and fall back to ones with fewer if it cannot
satisfy the longer ones.</p>
<p>The component factory for this is <strong>ConstructorInjection</strong>. It only handles constructor injection types of components. Factory <strong>AdaptiveInjection</strong>
@@ -26,7 +26,7 @@
</div>
<p>Setter methods (those prefixed with 'set') may not be your
preferred choice. You can force a different prefix to be choosable in
-Apache Composer, such as 'init' or 'inject'.</p>
+Container, such as 'init' or 'inject'.</p>
<p>The component factory for this is <strong>SetterInjection</strong>. It only handles setter injection types of components.</p>
<p>Factory <strong>AdaptiveInjection</strong> can also handle setter injection types, though it requires that the component was registered with the <a href="properties.html">property</a> 'SDI' in order to activate the Setter Injection functionality. <strong>AdaptiveInjection</strong> will also fall through to constructor injection if there is no SDI property. </p>
<p>If you want to use an prefix other than 'set', then specify your preferred prexix in the non-default constructor for <strong>SetterInjection</strong>.</p>
@@ -43,7 +43,7 @@
<p>The component factory for this is a class<strong> AnnotatedFieldInjection</strong>. It only handles field-annotation injection types of components.</p>
<p>Additionally component factory <strong>AdaptiveInjection</strong>
can also handle field annotation types, if the @Inject annotation from
-Apache Composer's codebase is used as the marker for injection. <strong>AdaptiveInjection</strong> will also fall through to constructor injection if there is no recognised @Inject annotation.</p>
+Container's codebase is used as the marker for injection. <strong>AdaptiveInjection</strong> will also fall through to constructor injection if there is no recognised @Inject annotation.</p>
<p>If you want to use an @Inject annotation from another codebase, then
specify the preferred annotation class in the constructor for <strong>AnnotatedFieldInjection</strong>.</p>
<h3>Annotated Method Dependency Injection </h3>
@@ -56,7 +56,7 @@
<p>The component factory for this is <strong>AnnotatedMethodInjection</strong>. It only handles method-annotation injection types of components.</p>
<p>Additionally component factory <strong>AdaptiveInjection</strong>
can also handle method-annotation injection types, if the @Inject
-annotation from Apache Composer's codebase is used as the marker for
+annotation from Container's codebase is used as the marker for
injection. AdaptiveInjection will also fall through to constructor
injection if there is no recognised annotation.</p>
<p>If you want to use an @Inject annotation from another codebase, then
@@ -71,10 +71,10 @@
<p>The component factory for this is <strong>MethodInjection</strong>. It only handles method-injection types of components.</p>
<p>Additionally component factory <strong>AdaptiveInjection</strong> can also handle method-injection types, but only if the METHOD_INJECTION characteristic is specified.</p>
-<h2>Using Apache Composer with Injection Types</h2>
+<h2>Using Container with Injection Types</h2>
<p>Explicit Constructor Injection:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new ConstructorInjection());<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new ConstructorInjection());<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Constructor Injection, is a default too (via AdaptiveInjection):</p>
<div class="source">
@@ -82,31 +82,31 @@
</div>
<p>Explicit Setter Injection:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new SetterInjection());<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new SetterInjection());<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Annotated Field injection:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new AnnotatedFieldInjection();<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new AnnotatedFieldInjection();<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Annotated Field injection, with alternate Annotation:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new AnnotatedFieldInjection(MyInjectAnnotaton.class);<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new AnnotatedFieldInjection(MyInjectAnnotaton.class);<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Annotated Method injection:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new AnnotatedMethodInjection();<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new AnnotatedMethodInjection();<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Annotated Method injection, with alternate Annotation:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new AnnotatedMethodInjection(MyInjectAnnotaton.class);<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new AnnotatedMethodInjection(MyInjectAnnotaton.class);<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Method injection, implicit injection method prefix ('inject'):</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new MethodInjection();<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new MethodInjection();<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p>Explicit Method injection, explicit injection method prefix:</p>
<div class="source">
- <pre>container = new DefaultApache Composer(new MethodInjection("setDependencies");<br />container.addComponent(Apple.class);<br /></pre>
+ <pre>container = new DefaultContainer(new MethodInjection("setDependencies");<br />container.addComponent(Apple.class);<br /></pre>
</div>
<p> Method injection, via a characteristic:</p>
<div class="source">
Modified: incubator/composer/trunk/composer-site/src/site/content/interception.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/interception.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/interception.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/interception.html Mon Feb 4 03:43:57 2008
@@ -50,7 +50,7 @@
}
}
...
-container = new DefaultApache Composer(new Intercepting());
+container = new DefaultContainer(new Intercepting());
container.addComponent(Apple.class, BraeburnApple.class);
Intercpeted intercepted = container.getComponentAdapter(Apple.class).findAdapterOfType(Intercpeted.class);
intercepted.pre(Apple.class, new BiteReporter(intercepted.getController()));
Modified: incubator/composer/trunk/composer-site/src/site/content/introduction.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/introduction.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/introduction.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/introduction.html Mon Feb 4 03:43:57 2008
@@ -9,24 +9,24 @@
<h2>Basics</h2>
-<p>This is a quick introduction to Apache Composer's most important features. Read through it to get an idea of what
- Apache Composer is and isn't. </p>
+<p>This is a quick introduction to Container's most important features. Read through it to get an idea of what
+ Container is and isn't. </p>
-<p>Apache Composer's most important feature is its ability to instantiate arbitrary objects. This is done through its API,
+<p>Container's most important feature is its ability to instantiate arbitrary objects. This is done through its API,
which is similar to a hash table. You can put java.lang.Class objects in and get object instances back.</p>
<p>Example:</p>
<div class="source">
<div>
- <pre>MutableApache Composer container = new DefaultContainer();
+ <pre>MutableContainer container = new DefaultContainer();
container.addComponent(ArrayList.class);
List list = (List) container.getComponent(ArrayList.class);</pre>
</div>
</div>
<p>(i)<a
- href="http://www.containercontainer.org/containercontainer/latest/containercontainer/apidocs/org/containercontainer/MutableApache Composer.html">MutableApache Composer
+ href="http://www.containercontainer.org/containercontainer/latest/containercontainer/apidocs/org/containercontainer/MutableContainer.html">MutableContainer
API<sup><img
class="rendericon" src="/images/icons/linkext7.gif" height="7" width="7" align="absmiddle" alt=""
border="0" /></sup></a></p>
@@ -39,8 +39,8 @@
</div>
</div>
-<p>With a trivial example such as this there is no point in using Apache Composer. This was just to illustrate the basic
- API. Apache Composer becomes useful with larger number of classes and interfaces having complex dependencies between
+<p>With a trivial example such as this there is no point in using Container. This was just to illustrate the basic
+ API. Container becomes useful with larger number of classes and interfaces having complex dependencies between
each other:</p>
<table>
<tbody>
@@ -55,12 +55,12 @@
</tbody>
</table>
<p>(Green means class, Yellow means interface).<br />
- Apache Composer identifies dependencies by looking at the
+ Container identifies dependencies by looking at the
constructors of registered classes (<a
href="constructor-injection.html"
title="Constructor Injection">Constructor Injection</a>).
- Apache Composer can also be though of as a generic factory that
- can be configured dynamically. Apache Composer is able to
+ Container can also be though of as a generic factory that
+ can be configured dynamically. Container is able to
instantiate a complex graph of several interdependent objects.</p>
<h2>Write some simple classes
@@ -136,12 +136,12 @@
<h2>Assemble components</h2>
-<p>You tell Apache Composer what classes to manage by registering them like this (the order of registration has no
+<p>You tell Container what classes to manage by registering them like this (the order of registration has no
significance):</p>
<div class="source">
<div>
- <pre>MutableApache Composer container = new DefaultContainer();
+ <pre>MutableContainer container = new DefaultContainer();
container.addComponent(Apple.class);
container.addComponent(Juicer.class);
container.addComponent(Peeler.class);</pre>
@@ -149,14 +149,14 @@
</div>
<p>(i)<a
- href="http://www.containercontainer.org/containercontainer/latest/containercontainer/apidocs/org/containercontainer/MutableApache Composer.html">MutableApache Composer
+ href="http://www.containercontainer.org/containercontainer/latest/containercontainer/apidocs/org/containercontainer/MutableContainer.html">MutableContainer
API<sup><img
class="rendericon" src="/images/icons/linkext7.gif" height="7" width="7" align="absmiddle" alt=""
border="0" /></sup></a></p>
<h2>Instantiate components</h2>
-<p>You can tell Apache Composer to give you an instance of a class like this (provided it has been registered
+<p>You can tell Container to give you an instance of a class like this (provided it has been registered
previously):</p>
<div class="source">
@@ -165,7 +165,7 @@
</div>
</div>
-<p>This will cause Apache Composer to do something similar to this behind the scenes (except that Apache Composer uses
+<p>This will cause Container to do something similar to this behind the scenes (except that Container uses
reflection):</p>
<div class="source">
@@ -178,12 +178,12 @@
</div>
<p><img class="emoticon" src="/images/icons/emoticons/information.gif" height="16" width="16" align="absmiddle" alt=""
- border="0" /> Note how Apache Composer figures out that Apple is a Peelable, so that it can be passed to Peeler
+ border="0" /> Note how Container figures out that Apple is a Peelable, so that it can be passed to Peeler
and Juicer's constructors.</p>
<h2>Container hierarchies</h2>
- <p>Apache Composer provides a powerful alternative to the <a
+ <p>Container provides a powerful alternative to the <a
href="singleton-antipattern.html" title="Singleton">Singleton</a>.
With container hierarchies you can create singleton-like objects
where you have fine grained control over the visibility scope of
@@ -206,9 +206,9 @@
<div class="source">
<div>
<pre>// Create x hierarchy of containers
-MutableApache Composer x = new DefaultContainer();
-MutableApache Composer y = new DefaultApache Composer( x );
-MutableApache Composer z = new DefaultApache Composer( y );
+MutableContainer x = new DefaultContainer();
+MutableContainer y = new DefaultContainer( x );
+MutableContainer z = new DefaultContainer( y );
// Assemble components
x.addComponent(Apple.class);
@@ -245,7 +245,7 @@
<h2>Lifecycle</h2>
-<p>Apache Composer has support for <a href="lifecycle.html" title="Lifecycle">Lifecycle</a>. If your classes implement <a
+<p>Container has support for <a href="lifecycle.html" title="Lifecycle">Lifecycle</a>. If your classes implement <a
href="http://www.containercontainer.org/containercontainer/latest/containercontainer/apidocs/org/containercontainer/Startable.html">Startable<sup><img
class="rendericon" src="/images/icons/linkext7.gif" height="7" width="7" align="absmiddle" alt=""
border="0" /></sup></a>, you can control the lifecycle of all your objects with a simple method call on the
@@ -258,8 +258,8 @@
<table>
<tbody>
<tr>
- <th> MutableApache Composer.start()</th>
- <th> MutableApache Composer.stop()</th>
+ <th> MutableContainer.start()</th>
+ <th> MutableContainer.stop()</th>
</tr>
<tr>
<td><img src="images/start-container.png" align="absmiddle" border="0" /></td>
@@ -274,8 +274,8 @@
<table>
<tbody>
<tr>
- <th> MutableApache Composer.start()</th>
- <th> MutableApache Composer.stop()</th>
+ <th> MutableContainer.start()</th>
+ <th> MutableContainer.stop()</th>
</tr>
<tr>
<td><img src="images/start-hierarchy.png" align="absmiddle" border="0" /></td>
@@ -291,8 +291,8 @@
<div class="source">
<div>
- <pre>MutableApache Composer parent = new DefaultApache Composer(new Caching());
-MutableApache Composer child = new DefaultApache Composer(parent);
+ <pre>MutableContainer parent = new DefaultContainer(new Caching());
+MutableContainer child = new DefaultContainer(parent);
// We must let the parent container know about the child container.
parent.addComponent(child);
// This will start the parent, which will start the child.
@@ -301,7 +301,7 @@
</div>
<p><strong><img class="emoticon" src="/images/icons/emoticons/warning.gif" height="16" width="16" align="absmiddle" alt="warning"
- border="0" /> </strong>Lifecycle is really only going to work for Apache Composers that are also caching component instances. Caching was a default in Apache Composer 1.x, but is not for 2.x - be warned!</p>
+ border="0" /> </strong>Lifecycle is really only going to work for Containers that are also caching component instances. Caching was a default in Container 1.x, but is not for 2.x - be warned!</p>
<p><img class="emoticon" src="/images/icons/emoticons/warning.gif" height="16" width="16" align="absmiddle" alt=""
border="0" /> Calling lifecycle methods on a container that has a parent container will <b>not</b> propagate the
lifecycle to the parent container. </p>
@@ -312,7 +312,7 @@
<h3>Contrasting Usage Styles </h3>
- <p>With Apache Composer you add components and get instances out in two styles. </p>
+ <p>With Container you add components and get instances out in two styles. </p>
<p>Classic bean style: </p>
Modified: incubator/composer/trunk/composer-site/src/site/content/inversion-of-control-history.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/inversion-of-control-history.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/inversion-of-control-history.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/inversion-of-control-history.html Mon Feb 4 03:43:57 2008
@@ -59,7 +59,7 @@
by constructor was more elegant. Latterly we are inclined to agree. At
that moment in time (the spring of 2003) there were no implementation
of the constructor injection idea, so it seemed logical for the initial
-Apache Composer leads (Paul Hammant and Aslak Hellesoy) who liked the
+Container leads (Paul Hammant and Aslak Hellesoy) who liked the
idea, to kick off the project.</p>
<p>The added advantage is that CDI Components cannot be instantiated
with missing dependencies. Thus the compiler or IDE will catch
@@ -76,7 +76,7 @@
setter as "type 2" and constructor as "type 3". He went as far as
publishing an <a href="http://java.sys-con.com/read/38102.htm">article</a> on it in Java Developer Journal. </p>
<p><em>December 2003</em>; Rod Johnson of the Spring Framework team,
-Paul Hammant (former Avaloner, and co-lead of Apache Composer), Mike
+Paul Hammant (former Avaloner, and co-lead of Container), Mike
Royle, with Martin Fowler (by email) say down and played with some of
the language of Martin's forthcoming article. Martin had drafted this
article entirely independently of this team but had be kind enough to
Modified: incubator/composer/trunk/composer-site/src/site/content/inversion-of-control.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/inversion-of-control.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/inversion-of-control.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/inversion-of-control.html Mon Feb 4 03:43:57 2008
@@ -22,7 +22,7 @@
<h3>Types of IoC</h3>
-<p>There are many types of IoC, but we'll concentrate on the type of IoC that Apache Composer introduced to the community
+<p>There are many types of IoC, but we'll concentrate on the type of IoC that Container introduced to the community
- <a href="constructor-injection.html" title="Constructor Injection">Constructor Injection</a>. </p>
<h3>IoC History</h3>
@@ -44,7 +44,7 @@
do its job. It instead <em>declares</em> these dependencies, and the container supplies them. Thus the name
IoC/DIP/Hollywood Principle. The control of the dependencies for a given component is inverted. It is no longer the
component itself that establishes its own dependencies, but something on the outside. That something could be a
- container like Apache Composer, but could easily be normal code instantiating the component in an embedded sense.</p>
+ container like Container, but could easily be normal code instantiating the component in an embedded sense.</p>
<h3>Examples</h3>
@@ -162,7 +162,7 @@
</div>
<h3>Notes </h3>
-<p>The lifecycle interfaces for Apache Composer are the only characterising API elements for a component. If Startable was
+<p>The lifecycle interfaces for Container are the only characterising API elements for a component. If Startable was
in the JDK, there would be no need for this. Sadly, it also menas that every framework team has to write their own
Startable interface. </p>
@@ -174,7 +174,7 @@
<p>Of course, in all of these discussions, it is important to point out that logging is a common exception to the IoC
rule. Apache has two static logging frameworks that are in common use: Commons-Logging and Log4J. Neither of these is
designed along IoC lines. Their typical use is static accessed whenever it is felt appropriate in an application.
- Whilst static logging is common, the Apache Composer team do not recommend that developers of reusable components
+ Whilst static logging is common, the Container team do not recommend that developers of reusable components
mandate a logging choice. We suggest instead that a Monitor component interface is created and default adapters are
provided to a number of the logging frameworks are provided.</p>
@@ -195,11 +195,11 @@
<ul>
<li>Constructor Dependency Injection (CDI) <br />
<br />
- Examples: Apache Composer, Spring Framework, (not in EJB 3.x sadly), Guice with Annotations
+ Examples: Container, Spring Framework, (not in EJB 3.x sadly), Guice with Annotations
</li>
<li>Setter Dependency Injection<br />
<br />
- Examples: Spring Framework, Apache Composer, EJB 3.0 & Guice with Annotations
+ Examples: Spring Framework, Container, EJB 3.0 & Guice with Annotations
</li>
<li>Interface Driven Setter Dependency Injection<br />
<br />
@@ -207,7 +207,7 @@
</li>
<li>Field Dependency Injection<br />
<br />
- Examples: Plexus, Apache Composer & Guice with Annotations.
+ Examples: Plexus, Container & Guice with Annotations.
</li>
</ul>
</li>
@@ -228,7 +228,7 @@
href="setter-injection.html" title="Setter Injection">Setter Injection</a> for more information.</p>
<p>Note Field Injection was categorised but there was was really no interest it until the EJB3.0 specification rolled out. Getter
- Injection flourished for a while, but did not take and was never supported by the Apache Composer team.</p>
+ Injection flourished for a while, but did not take and was never supported by the Container team.</p>
<h2>Examples of Common Types</h2>
Modified: incubator/composer/trunk/composer-site/src/site/content/lifecycle.html
URL: http://svn.apache.org/viewvc/incubator/composer/trunk/composer-site/src/site/content/lifecycle.html?rev=618243&r1=618242&r2=618243&view=diff
==============================================================================
--- incubator/composer/trunk/composer-site/src/site/content/lifecycle.html (original)
+++ incubator/composer/trunk/composer-site/src/site/content/lifecycle.html Mon Feb 4 03:43:57 2008
@@ -15,14 +15,14 @@
and stop may happen more than one for the life of an application.
Disposal may happen once only, before the component is eligible for
garbage collection.</p>
-<p><strong>Lifecycle is really only going to work for Apache Composers that are also caching component instances. Caching was a default in Apache Composer 1.x, but is not for 2.x - be warned!</strong></p>
+<p><strong>Lifecycle is really only going to work for Containers that are also caching component instances. Caching was a default in Container 1.x, but is not for 2.x - be warned!</strong></p>
<p>Thus lifecycle implies three methods:</p>
<ul>
<li>start</li>
<li>stop</li>
<li>dispose</li>
</ul>
-<p>In Apache Composer we think allow a pluggable LifecycleStrategy.</p>
+<p>In Container we think allow a pluggable LifecycleStrategy.</p>
<h3>Startable</h3>
<p>Our own interface for startable. We wish it were in the JDK,
because we're big into making components unecumbered by the trappings of
@@ -44,7 +44,7 @@
...
-container = new DefaultApache Composer(new StartableLifecycleStrategy());
+container = new DefaultContainer(new StartableLifecycleStrategy());
container.addComponent(Apple.class);
container.start();
// start gets called
@@ -71,7 +71,7 @@
...
-container = new DefaultApache Composer(new ReflectionLifecycleStrategy());
+container = new DefaultContainer(new ReflectionLifecycleStrategy());
container.addComponent(Apple.class);
container.start();
// start gets called
@@ -82,7 +82,7 @@
<p>If you have other synonyms for start/stop/dispose, just extend
the ReflectionLifecycleStrategy class and provide them.</p>
<h3>No Lifecycle</h3>
-<p>DefaultApache Composer does sets StartableLifecycleStrategy by
+<p>DefaultContainer does sets StartableLifecycleStrategy by
default. You can specify NullLifecycleStrategy instead if you are sure
that no components honor any lifecycle concept..</p>
<h3>Custom Lifecycles</h3>