开源框架 Seasar2

虽然一说到规约就容易产生麻烦之类的想法，“推荐而已，如果遵守的话就能使开发愉快”的话，遵守规约的动机就产生了。这才是问题的重点。

如上的设定，可以做如下化简

<component name="greetingClient"
    class="examples.di.impl.GreetingClientImpl">
</component>

实际上?刚才的AOP的例子也适用“Convention over Configuration”。 通常在AOP中，AOP的模块在什么地方适用是由pointcut指定的，S2AOP 的情况下? 如果遵守所谓“使用Interface”这个推荐的规约 ，不指定pointcut，自动的适用于在Interface中定义的所有方法。因为有这个机能，在刚才的那个例子中，就没有必要指定pointcut。

虽然根据“Convention over Configuration”，DI和AOP的设定可以得以简化，需要处理的组件数增加了、仅仅组件的注册也会变成一个非常累的作业。那么这个组件注册自动化就叫做组件自动注册 机能。 刚才的GreetingImpl、GreetingClientImpl的注册自动化如下。

<component
  class="org.seasar.framework.container.autoregister.FileSystemComponentAutoRegister">
    <initMethod name="addClassPattern">
        <arg>"examples.di.impl"</arg>
        <arg>".*Impl"</arg>
    </initMethod>
</component>

FileSystemComponentAutoRegister组件将addClassPattern方法指定的类从文件系统中探寻出来，自动注册到S2Container中。关于initMethod标签，请参照方法函数注入 。

addClassPattern方法的第一个参数是想要注册的组件的包的名字。 子包的内容也会用回归的方式检索。第二个参数是类的名字。可以使用正则表达式。也可以用“,”做分隔符指定复数个设定。

根据组件自动注册原则，即使后续追加组件的情况下，也没有必要追加设定，这样手续就大大地简化了。

如果组件的自动化注册可以了，接下来就会想让AOP的注册也自动化了吧。刚才的GreetingImpl、GreetingClientImp的AOP注册自动化的设定如下。

<include path="aop.dicon"/>
...
<component
  class="org.seasar.framework.container.autoregister.AspectAutoRegister">
    <property name="interceptor">aop.traceInterceptor</property>
    <initMethod name="addClassPattern">
        <arg>"examples.di.impl"</arg>
        <arg>".*Impl"</arg>
    </initMethod>
</component>

用interceptor属性指定AOP的名称。addClassPattern方法同组件的自动化注册时的用法一样，这里就不做特殊的说明了。 组件自动化注册和AOP自动化注册的例子如下。

GreetingMain4.dicon

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC "-//SEASAR//DTD S2Container 2.3//EN" 
    "http://www.seasar.org/dtd/components23.dtd">
<components>
    <include path="aop.dicon"/>

    <component
      class="org.seasar.framework.container.autoregister.FileSystemComponentAutoRegister">
        <initMethod name="addClassPattern">
            <arg>"examples.di.impl"</arg>
            <arg>".*Impl"</arg>
        </initMethod>
    </component>

    <component
      class="org.seasar.framework.container.autoregister.AspectAutoRegister">
        <property name="interceptor">aop.traceInterceptor</property>
        <initMethod name="addClassPattern">
            <arg>"examples.di.impl"</arg>
            <arg>".*Impl"</arg>
        </initMethod>
    </component>
</components>

那么来执行一下GreetingMain4吧。 自动注册的情况下，S2Container#init()和S2Container#destroy()的调用是必要的。

GreetingMain4.java

package examples.di.main;

import org.seasar.framework.container.S2Container;
import org.seasar.framework.container.factory.S2ContainerFactory;

import examples.di.GreetingClient;

public class GreetingMain4 {

    private static final String PATH =
        "examples/di/dicon/GreetingMain4.dicon";

    public static void main(String[] args) {
        S2Container container =
            S2ContainerFactory.create(PATH);
        container.init();
        try {
            GreetingClient greetingClient = (GreetingClient)
                container.getComponent("greetingClient");
            greetingClient.execute();
        } finally {
            container.destroy();
        }
    }
}

执行的结果同GreetingMain3一样如下列出。

DEBUG 2005-10-12 16:00:08,093 [main] BEGIN examples.di.impl.GreetingClientImpl#execute()
DEBUG 2005-10-12 16:00:08,103 [main] BEGIN examples.di.impl.GreetingImpl#greet()
DEBUG 2005-10-12 16:00:08,103 [main] END examples.di.impl.GreetingImpl#greet() : Hello World!
Hello World!
DEBUG 2005-10-12 16:00:08,103 [main] END examples.di.impl.GreetingClientImpl#execute() : null

大多数的情况下?自动注册和自动绑定的组合方式都能顺利的进行下去。不想要自动注册的组件存在的情况下，自动注册组件中准备了addIgnoreClassPattern方法，可以指定自动注册外的组件。

不想要自动绑定的属性存在的情况下，使用Binding备注码 ，不使用设定文件也可以做细节的调整。

使用Hotswap 的话?应用程序在运行中重新书写更换类文件，马上就能够直接测试结果。不需要一个一个地将应用程序在启动，因此开发的效率能够得到大幅度的提高。

现在，关于S2Container的高级使用方法也可以掌握了。这之后嘛，只要根据需要参照对应的操作手册就可以了。

S2Container参考

需要作成的文件

为了使用S2Container，定义文件的做成是必要的。定义文件就像是为了组织组件而制作的设计书一样的东西。形式为XML，后缀为dicon。

S2Container的定义

S2Container的定义、象下面这样。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC "-//SEASAR//DTD S2Container 2.3//EN"
"http://www.seasar.org/dtd/components23.dtd">
<components>
    <component name="..." class="...">
            ...
    </component>
    <component name="..." class="...">
            ...
    </component>
</components>

DOCTYPE是不能省略的。dicon做成的时候、请将前述例子拷贝粘贴。根是components标签 。每一个组件用component标签 定义。用component标签的class属性指定组件的类的全名。在name属性中、指定组件的名称。详细内容请参照S2Container定义标签参考 。

<components>
    <component name="hoge" class="examples.dicon.HogeImpl"/>
</components>

S2Container的生成

S2Container的生成方法有两种。

• 使用SingletonS2ContainerFactory。
• 使用S2ContainerFactory。

使用SingletonS2ContainerFactory

使用SingletonS2ContainerFactory的情况下，使用如下方法。

- org.seasar.framework.container.factory.SingletonS2ContainerFactory#init()

定义文件使用的是CLASSPATH所指定的路径中存在的app.dicon。

做成的S2Container，无论在什么地方都是可以从如下方法中取得。

- org.seasar.framework.container.factory.SingletonS2ContainerFactory#getContainer()

SingletonS2ContainerFactory.init();
...
S2Container container = SingletonS2ContainerFactory.getContainer();

定义文件的路径需要被指定的情况下应在调用init()之前执行如下方法。

- org.seasar.framework.container.factory.SingletonS2ContainerFactory#setConfigPath(String Path)

参数path是相对于以CLASSPATH指定的路径为根的定义文件的绝对路径。例如，WEB-INF/classes/aaa.dicon 的情况下就是aaa.dicon，WEB-INF/classes/aaa/bbb/ccc.dicon的情况下就是aaa/bbb/ccc.dicon。分隔符在Windows和Unix下都是/。

private static final String PATH = "aaa/bbb/ccc.dicon";
...
SingletonS2ContainerFactory.setConfigPath(PATH);
SingletonS2ContainerFactory.init();
...
S2Container container = SingletonS2ContainerFactory.getContainer();

使用S2ContainerFactory

使用S2ContainerFactory的场合下，使用如下方法。

- org.seasar.framework.container.factory.S2ContainerFactory#create(String path)

S2Container生成之后需要许呼叫下一个方法。

- org.seasar.framework.container.S2Container#init()

private static final String PATH = "aaa/bbb/ccc.dicon";
...
S2Container container = S2ContainerFactory.create(PATH);
container.init();

用这个方法取得的组件的实例，有必要进行在应用中的管理。

组件的取得

从S2Container中将组件取出来，使用下面的方法。

- org.seasar.framework.container.S2Container#getComponent(Object componentKey)

参数中指定的是组件的类或者是组件的名称。详细的请参照component标签 。要指定组件的类，只要是 组件 instanceof 类 的操作返回为true的类就能够指定。但是、S2Container中所指定的类对应了好几个实装的组件的时候，S2Container将不能判断返回哪一个组件为好，这样就会发生TooManyRegistrationRuntimeException。请指定实装组件为唯一的类。也可以用组件名称取得组件。这种情况下也是同样，用一个名称的复数个组件被注册的情况下，将发生TooManyRegistrationRuntimeException。指定组件名的场合下，因为也可能发生拼写错误，所以尽可能的指定组件的类为好。

例）通过指定类来取得组件的场合

S2Container container = S2ContainerFactory.create(PATH);
Hoge hoge = (Hoge) container.getComponent(Hoge.class);

例）通过指定组件名来取得组件场合

S2Container container = S2ContainerFactory.create(PATH);
Hoge hoge = (Hoge) container.getComponent("hoge");

Dependency Injection的类型

在Dependency Injection中，组件的构成所必要的值是用构造函数来设定(Constructor Injection)，还是用设定函数来设定(Setter Injection)，或者是用初始化函数来设定(Method Injection)，这样进行分类。Method Injection是S2Container的本源。S2Container支持以上所有类型和混合类型。

构造函数?注入

对构造函数的参数进行DI，这就是构造函数注入。
S2Container的定义文件中，记述如下内容。

• 组件的指定
  组件，用component标签来组建。用class指定对应的类。
  也可以用name属性给组件起名称。
• 构造函数的参数的指定
  组件的构造函数的参数用component标签的子标签arg标签来指定。
  值为字符串的时候，用双引号(")括起来。

<components>
    <component name="..." class="...">
          <arg>...</arg>
    </component>
</components>

设定函数?注入

设定函数注入是指对于任意一个属性变量使用设定函数来行使DI。
S2Container的定义文件中作如下内容的记述。

• 组件的指定
  组件的指定同构造函数注入相同。
• 属性变量的指定
  组件的属性变量用component标签的子标签property来指定。
  用name属性来指定变量的名称。

<components>
    <component name="..." class="...">
          <property name="...">...</property>
    </component>
</components>

方法函数?注入

方法函数注入是指，通过任意一个函数的调用来完成DI的功能。
S2Container的定义文件中，记述如下内容。

• 组件的指定
  组件的指定同构造函数注入相同。
• 初始化方法函数的指定
  使用initMethod标签，调用组件的任意一个方法函数。在name属性中，指定方法函数的名称。 用arg标签指定参数，name属性省略，在正文中，使用OGNL式 也可以。

<components>
    <component name="..." class="...">
        <initMethod name="...">
            <arg>...</arg>
        </initMethod>
    </component>
</components>

S2Container定义的分割和引入

所有的组件用一个文件来设定的话，很快就会变得臃肿而难以管理。因此，S2Container就具有了将组件的定义进行复数个分割的机能和将多个分割的定义文件引入而组织成一个文件的机能。S2Container定义文件的引入方法如下。

<components>
    <include path="bar.dicon"/>
</components>

include标签 的path属性被用来指定想要引入的S2Container定义文件的路径。详细情况请参照include标签 。
组件的检索顺序，先是在自身注册的文件中寻找组件，没有找到所需组件的情况下，将按照include的顺序在子定义文件中查找注册到S2Container中的组件，最先找到的那个组件将被返回。

<components>
    <include path="aaa.dicon"/>
    <include path="bbb.dicon"/>
    <component class="example.container.Foo" />
</components>

命名空间

组件的定义被分割的情况下，为了不让复数个组件的定义名称发生冲突，可以用components标签 的namespace属性指定命名空间。

foo.dicon

<components namespace="foo">
    <component name="aaa" .../>
    <component name="bbb" ...>
        <arg>aaa</arg>
    </component>
</components>

bar.dicon

<components namespace="bar">
    <include path="foo.dicon"/>
    <component name="aaa" .../>
    <component name="bbb" ...>
        <arg>aaa</arg>
    </component>
    <component name="ccc" ...>
        <arg>foo.aaa</arg>
    </component>
</components>

app.dicon

<components>
    <include path="bar.dicon"/>
</components>

在同一个组件定义文件中可以不需要指定命名空间而调用组件。调用其它S2Container文件中定义的组件时，要在组件名前加上命名空间。foo.aaa 和 bar.aaa 虽然有相同名称的组件，但是因为命名空间的不同，就被认为是不同的组件。

实例(instance)管理

在S2Container中，怎么样对实例进行管理，这个设定是用component标签 的instance属性。

生存周期

使用initMethod 和 destroyMethod组件的生存周期也可以用容器来管理。在S2Container的开始时用(S2Container.init())调用initMethod标签 中指定的方法，S2Container结束时用(S2Container.destroy())调用destroyMethod标签 中指定的方法。initMethod将按照容器中注册的组件的顺序来执行组件，destroyMethod则按照相反的顺序去执行。instance属性是singleton之外的情况下，指定了destroyMethod也会被忽视。java.util.HashMap#put()方法中初始化(给aaa赋值为111)?结束处理(给aaa赋值为null)的设定，向下面那样。

<components namespace="bar">
    <component name="map" class="java.util.HashMap">
        <initMethod name="put">
            <arg>"aaa"</arg>
            <arg>111</arg>
        </initMethod>
        <destroyMethod name="put">
            <arg>"aaa"</arg>
            <arg>null</arg>
        </destroyMethod>
    </component>
</components>

自动绑定

组件间的依存关系，类型是interface的场合时，将由容器来自动解决。这是在S2Container被默认的，指定component标签 的autoBinding属性可以进行更加细致的控制。

构造函数的自动绑定规则如下所示。

• 明确指定了构造函数的参数的情况下，自动绑定将不再适用。
• 不属于上述情况，如果是定义了没有参数的默认的构造函数的话，对于这个构造函数，自动绑定也不适用。
• 不属于上述情况，参数的类型全是interface并且参数数目最多的构造函数将被使用。 这样，对于从容器中取得参数类型的实装组件，自动绑定是适用的。
• 如果不是以上情况，自动绑定将不适用。

属性变量的自动绑定规则如下。

• 明确指定了属性变量的情况下，自动绑定将不适用。
• 不属于上述情况，如果在容器的注册组件中存在着可以代入属性变量中的同名组件，自动绑定将适用于该组件。
• 不属于上述情况，属性变量的类型是interface并且该属性类型的实装组件在容器中注册了的话，自动绑定是适用的。
• 如果不是以上情况，自动绑定将不适用。

用property标签的bindingType属性，可以更加细致的控制属性变量。

在组件中利用S2Container

不想让组件依存于S2Container的情况下，根据组件的具体情况，在组件中需要调用S2Container的方法，这样的场合也许会存在。S2Container自身也以container的名称，自我注册了。所以可以在arg,property标签的正文中指定container，从而取得容器的实例。还有，S2Container类型的setter方法定义好了后也可以做自动绑定的设定。用arg,property标签指定container的情况下，向下面这样进行。

<components>
    <component class="examples.dicon.BarImpl">
        <arg>container</arg>
    </component>

    <component class="examples.dicon.FooImpl">
        <property name="foo">container</property>
    </component>
</components>

S2ContainerServlet

到此为止，在Java application中，是用明确表示的方法做成S2Container的，Web application的情况下，由谁来作成S2Container呢？为了达到这个目的，准备了以下的类。

• org.seasar.framework.container.servlet#S2ContainerServlet

为了使用S2ContainerServlet，在web.xml中记述如下项目。

<servlet>
    <servlet-name>s2servlet</servlet-name>
    <servlet-class>org.seasar.framework.container.servlet.S2ContainerServlet</servlet-class>
    <init-param>
        <param-name>configPath</param-name>
        <param-value>app.dicon</param-value>
    </init-param>
    <init-param>
        <param-name>debug</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>s2servlet</servlet-name>
    <url-pattern>/s2servlet</url-pattern>
</servlet-mapping>

用configPath来指定作为根的S2Container的定义路径。定义文件将放在WEB-INF/classes中。对于S2ContainerServlet，为了比其它的servlet更早的起动，请做load-on-startup标签的调整。S2ContainerServlet起动之后，可以用如下的方法函数取得S2Container的实例。

• org.seasar.framework.container.factory.SingletonS2ContainerFactory#getContainer()

另外，S2Container的生命周期和S2ContainerServlet是连动的。debug变量被设为true的话，按照以下的方法，可以将运行中的S2Container再次起动。xxx是Web application的context名。

http://localhost:8080/xxx/s2servlet?command=restart
            

在使用了S2ContainerServlet的情况下，ServletContext将会作为一个组件可以用servletContext的名字来访问。

app.dicon的角色

根的S2Container的定义文件，按照惯例用app.dicon的名称。通常放在WEB-INF/classes中就好了。

AOP的适用

在组件中AOP 的适用情况也可以被设定。比如，想要在ArrayList中设定TraceInterceptor 使用的情况下需要象下面这样做。

<components>
    <component name="traceInterceptor"
               class="org.seasar.framework.aop.interceptors.TraceInterceptor"/>
    <component class="java.util.ArrayList">
        <aspect>traceInterceptor</aspect>
    </component>
    <component class="java.util.Date">
        <arg>0</arg>
        <aspect pointcut="getTime, hashCode">traceInterceptor</aspect>
    </component>
</components>

aspect标签的正文中指定Interceptor 的名字。pointcut的属性中可以用逗号做分隔符指定AOP对象的方法的名字。pointcut的属性没有被指定的情况下，组件将把实装的interface的所有方法函数作为AOP的对象。方法函数的名称指定也可以用正则表达式(JDK1.4のregex)。这样的定义例子如下。

private static final String PATH =
    "examples/dicon/Aop.dicon";
S2Container container = S2ContainerFactory.create(PATH);
List list = (List) container.getComponent(List.class);
list.size();
Date date = (Date) container.getComponent(Date.class);
date.getTime();
date.hashCode();
date.toString();

执行结果。

BEGIN java.util.ArrayList#size()
END java.util.ArrayList#size() : 0
BEGIN java.util.Date#getTime()
END java.util.Date#getTime() : 0
BEGIN java.util.Date#hashCode()
BEGIN java.util.Date#getTime()
END java.util.Date#getTime() : 0
END java.util.Date#hashCode() : 0
BEGIN java.util.Date#getTime()
END java.util.Date#getTime() : 0

组件中也可以设定InterType 的适用情况。比如，在Hoge中设定PropertyInterType 的适用情况如下进行。

<components>
    <include path="aop.dicon"/>
    <component class="examples.Hoge">
        <interType>aop.propertyInterType</aspect>
    </component>
</components>

在interType标签的正文中指定InterType 的名称。

Meta数据

在components、component、arg、property标签中也可以指定Meta数据。meta标签将作为需要指定Meta数据的标签的字标签来指定Meta数据。例如，想要在components标签中指定Meta数据的情况时，象下面一样设定。

<components>
    <meta name="aaa">111</meta>
</components>

request的自动绑定

对于组件来说，也可以进行HttpServletRequest的自动绑定。为了实现这个目的，在组件中，定义了setRequest(HttpServletRequest request)方法。这样的话，S2Container就自动得设定了request。还有，需要象下面这样在web.xml中进行Filter的定义。

<web-app>
    <filter>
        <filter-name>s2filter</filter-name>
        <filter-class>org.seasar.framework.container.filter.S2ContainerFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>s2filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

同样地对HttpServletResponse、HttpSession、ServletContext也是只要定义了setter方法，就可以自动绑定了。而且，使用了S2ContainerFilter的话，HttpServletRequest、HttpServletResponse、HttpSession、ServletContext就可以各自用request、response、session、application的名字来做为组件被自由访问了。

组件的自动注册

根据自动绑定 的原理，DI的设定几乎可以做近乎全部的自动化。 使用备注码 就有可能进行更加细致的设定。 更进一步、对组件的注册也进行自动化的话，就可以称为组件的自动注册机能了。

org.seasar.framework.container.autoregister.FileSystemComponentAutoRegister

是从文件系统中将类检索出来对组件进行自动注册的组件。

org.seasar.framework.container.autoregister.JarComponentAutoRegister

从Jar文件中检索类自动注册组件的组件。

org.seasar.framework.container.autoregister.ComponentAutoRegister

将类从文件系统或者Jar文件中检索出来并将组件自动注册的组件。

AutoNaming

根据AutoNaming来控制组件名称。

org.seasar.framework.container.autoregister.DefaultAutoNaming

从类的完整合法名称中将类的包的那部分名称去掉，如果结尾是Impl或者Bean也要去掉，之后将开头的字母变成小写做为组件名称来设定。 例如，aaa.HogeImpl类的情况下，组件的名称就成了hoge。

org.seasar.framework.container.autoregister.QualifiedAutoNaming

将包的名字或者是一部分类的合法名做为组件名称的设定。从类的完整合法名的最后把Impl或者Bean去掉，开头字母小写，分隔点后紧接着的字母变成大写并取掉分隔点，将这个新的单词设定为组件的名称。
可以将包的开头的不要的部分做消除指定。
例如，aaa.bbb.ccc.ddd.HogeImpl类的情况下，将开头的aaa.bbb做消除指定的情况下组件的名称为，cccDddHogeになります。

例

<component
  class="org.seasar.framework.container.autoregister.FileSystemComponentAutoRegister">
    <property name="autoNaming">
        <component class="org.seasar.framework.container.autoregister.DefaultAutoNaming">
            <initMethod name="setCustomizedName">
                <arg>"examples.di.impl.HogeImpl"</arg>
                <arg>"hoge2"</arg>
            </initMethod>
        </component>
    </property>
    <initMethod name="addClassPattern">
        <arg>"examples.di.impl"</arg>
        <arg>".*Impl"</arg>
    </initMethod>
</component>

<component class="org.seasar.framework.container.autoregister.JarComponentAutoRegister">
    <property name="referenceClass">
        @junit.framework.TestSuite@class
    </property>
    <property name="jarFileNames">"junit.*"</property>
    <initMethod name="addClassPattern">
        <arg>"junit.framework"</arg>
        <arg>"TestSuite"</arg>
    </initMethod>
</component>

<component class="org.seasar.framework.container.autoregister.ComponentAutoRegister">
    <initMethod name="addReferenceClass">
        <arg>@aaa.bbb.ccc.ddd.HogeImpl@class</arg>
    </initMethod>
    <initMethod name="addClassPattern">
        <arg>"aaa.bbb"</arg>
        <arg>".*Impl"</arg>
    </initMethod>
</component>

AOP的自动注册

根据组件的自动注册 规则，组件的注册可以做到自动化。进一步，AOP的注册也可以做到自动化，这就是AOP的自动注册机能。

和组件的自动注册功能组和使用的场合下，必须在组件的自动注册设定之后，作AOP的自动注册的设定。对于适用于使用AOP的组件的记述，必须在AOP的自动注册设定之后进行。

<components>
    <!-- 1.组件的自动注册 -->
    <component class="org.seasar.framework.container.autoregister.ComponentAutoRegister">
        ...
    </component>

    <!-- 2.AOP的自动注册 -->
    <component class="org.seasar.framework.container.autoregister.AspectAutoRegister">
        ...
    </component>

    <!-- 3.其它的组件 -->
    <component class="...">
        ...
    </component>
    ...
<components>

org.seasar.framework.container.autoregister.AspectAutoRegister

通过指定类名的模式来进行AOP的自动注册的组件。

例

<include path="aop.dicon"/>
...
<component
  class="org.seasar.framework.container.autoregister.AspectAutoRegister">
    <property name="interceptor">aop.traceInterceptor</property>
    <initMethod name="addClassPattern">
        <arg>"examples.di.impl"</arg>
        <arg>".*Impl"</arg>
    </initMethod>
</component>

org.seasar.framework.container.autoregister.InterfaceAspectAutoRegister

针对某个interface的实装类进行AOP的自动注册的组件。

例

<include path="aop.dicon"/>
...
<component
  class="org.seasar.framework.container.autoregister.InterfaceAspectAutoRegister">
    <property name="interceptor">aop.traceInterceptor</property>
    <property name="targetInterface">@examples.Greeing@class</property>
</component>

META的自动注册

META信息也可以自动注册。

同组件的自动注册相组合使用的场合下，必须在组件的自动注册设定之后，做META的自动注册的设定记述。 调用META信息的组件必须在META自动注册的设定之后记述。

<components>
    <!-- 1.组件的自动注册 -->
    <component class="org.seasar.framework.container.autoregister.ComponentAutoRegister">
        ...
    </component>

    <!-- 2.META的自动注册 -->
    <component class="org.seasar.framework.container.autoregister.MetaAutoRegister">
        ...
    </component>

    <!-- 3.其它的组件 -->
    <component class="...">
        ...
    </component>
    ...
<components>

org.seasar.framework.container.autoregister.MetaAutoRegister

通过指定类名的模式来做META自动注册的组件。
被自动注册的META数据，将做为在这个组件自身的定义中一个叫做autoRegister的META数据的子数据来记述。