Struts2的IoC解析

原文地址：http://blog.csdn.net/yanlinwang/article/details/8944632

个人学习笔记，不保证内容的正确率。转载请声明！！

对于IoC来说，常见的就是Spring框架的了。并且在目前Java EE开发中，使用SSH框架时，也主要依赖于Spring框架所提供的IoC功能。但Struts2框架本身也提供了IoC的功能。本人对于Spring框架的IoC功能的实现没怎么做了解，所以也不对此发表什么见解。这里主要是对Struts2框架的IoC的使用方法和实现原理进行分析。纯属个人学习兴趣。。。。

在这其中参照了博文《Struts2源码分析-IoC容器的实现机制》，链接地址为http://blog.csdn.net/fcbayernmunchen/article/details/7686385 中的相关内容。

[IoC功能的使用]

首先如何理解IoC的含义呢，现在也常称为依赖注入（Dependency Injection，DI。各种称呼，对此略有点糊涂）。核心的意思就是把对象之间的耦合关系，交由外部去管理，一般就是一个容器（Container）对象。那容器，又是如何去获得关于对象的信息的呢，这就是配置文件的作用了。在Spring中，有applicationContext.xml配置文件。在Struts2中，有struts.xml配置文件。在这些配置文件中配置好对象信息，在加载的时候，这些配置文件会被解析，然后当对象被使用的时候，就通过配置文件找到相应的类，调用相应的方法等。。。。

大致是这么个思路，直接说有点抽象，下面用一个实际的例子来说明这种用法。

struts.xml中的配置项如下所示

<   bean   name   = "entity"   type   = "lynn.entity.Entity"   class   = "lynn.entity.Entity"  scope = "Scope.SINGLETON" />

配置了一个bean，名称是entity,类型是lynn.entity.Entity，实例化对象时，具体生成的是lynn.entity.Entity这个类的对象。在这个例子中type和class的值被设置成一样的。一般来说class描述的类应该是type类的子类，或是type描述的接口的实现类。scope指出了这个对象的生存范围，这里这个对象被设置成了一个单例形式的对象。也就是，所有通过Struts2的IoC获取的对象，都是同一个对象。

下面来看lynn.entity.Entity这个类的代码，如下所示

package   lynn.entity;

public   class   Entity {

       

          private   String   name   ;

          private   int   value   ;

       

       

          public   Entity(){

                 name =   "Lynn" ;

                 value =23;

       }

       

          public   void   setName(String name){

                 this . name   =name;

       }

       

          public   void   setValue( int   value){

                 this . value   =value;

       }

       

          public   String getName(){

                 return   name   ;

       }

          public   int   getValue(){

                 return   value   ;

       }

       

          @Override

          public   String toString(){

                 return   "Entity info:<"   + name   + ","   + value   + ">"   ;

       }

}

lynn.entity.Entity这个类没有什么特别之处，就是一个一般的Java Bean，只不过重写了toString方法，这样就可以直接将Entity对象的相关信息打印出来。

还有一个测试inject方法的类，叫做InjectTest类，这个类的代码如下所示

package   lynn.inject;

import   lynn.entity.Entity;

import   com.opensymphony.xwork2.inject.Inject;

public   class   InjectTest {

          @Inject (   "entity" )

          private   Entity   entity   ;

       

       

          @Inject

          public   void   injectTest( @Inject ( "entity" )Entity entity){

              System.   out .println(entity);

       }

       

          public   void   normalMethod(){

              System.   out .println( "normal method"   );

       }

}

主要注意这个类中加入的@Inject注释。这里指定的名称是“entity”，也就是前面在struts.xml中配置的那个java bean。

在测试项目中与lynn.entity.Entity和IoC相关的部分的代码如下所示

Container container=ServletActionContext. getContext ().getContainer();

InjectTest inject=   new   InjectTest();

Entity entity=container.getInstance(Entity.   class ,   "entity"   );

System.   out .println( "first mark: "   +entity);

entity.setName(   "yanlinwang" );

entity.setValue(50);

container.inject(inject);

Entity entity2=container.getInstance(Entity.   class , "entity"   );

System.   out .println( "second mark:"   +entity2);

在这段代码中，首先通过ServletActionContext.getContext().getContainer()获得用来管理对象关系的容器（Container）对象container，然后与IoC功能相关部分的代码是container.getInstance(Entity.   class   ,  "entity"   );和 container.inject(inject); 这里对getInstance对象调用了两次，并且在中间还对获取过的对象进行过修改，通过对两次获取到的对象的打印结果，来确定是不是像前面所说的那样，这个对象是一个单例对象。

项目运行后，与此部分相关的显示结果如下图所示

 

从运行结果来看，总共对这个对象打印了三次。出了在上面标出的"first mark"和"second mark"外，还进行了一次打印动作。是在InjectTest类的injectTest函数中。 第一次的打印结果是<Lynn,23>，这表明是调用了默认构造函数。在后续对这个entity对象的属性值进行了设定，然后进行container.inject(inject);时injectTest函数被调用，使得这个对象又被打印一次。这里显示的信息就是设置后的新值。然后再次通过容器获取这个对象，并且打印。这里打印出来的值与设置的值一样，表明这里获取的还是之前修改过的对象，所以，从这三次打印的结果来看，三次操作的都是同一个entity对象。

通过上面这个例子，也给出了IoC功能的一个形象说明。下面部分，将对Struts2的IoC的实现，进行解析。学习所致，不保证正确性！

[IoC功能的接口]

前面的例子中给出的对Struts2的IoC功能的使用，是通过一个容器（Container）对象来实现的。Container是一个接口类，它的源代码如下所示

public   interface   Container   extends   Serializable {

    /**

   * Default dependency name.

   */

  String   DEFAULT_NAME   =   "default" ;

    /**

   * Injects dependencies into the fields and methods of an existing object.

   */

    void   inject(Object o);

    /**

   * Creates and injects a new instance of type {@code implementation}.

   */

  <T> T inject(Class<T> implementation);

    /**

   * Gets an instance of the given dependency which was declared in

   *   {@link com.opensymphony.xwork2.inject.ContainerBuilder} .

   */

  <T> T getInstance(Class<T> type, String name);

    /**

   * Convenience method.&nbsp;Equivalent to {@code getInstance(type,

   * DEFAULT_NAME)}.

   */

  <T> T getInstance(Class<T> type);

 

    /**

   * Gets a set of all registered names for the given type

   *   @param   type The instance type

   *   @return   A set of registered names or empty set if no instances are registered for that type

   */

  Set<String> getInstanceNames(Class<?> type);

    /**

   * Sets the scope strategy for the current thread.

   */

    void   setScopeStrategy(Scope.Strategy scopeStrategy);

    /**

   * Removes the scope strategy for the current thread.

   */

    void   removeScopeStrategy();

}

由上面的代码结合前面的例子，可以看出获取对象和注入相关的接口是getInstance和inject的重载方法。 这就是IoC功能的相关外部接口。那么，这个过程是如何实现的呢？

[IoC功能相关的数据结构----容器实现类ContainerImpl的成员变量]

要了解Struts2的IoC的实现，就需要从上面相关容器接口方法的具体实现来看。在Struts2中，实现这些相关方法的类是ContainerImpl，它实现了一个具体的容器的功能。通过对这个容器实现类进行解析，就可以大致了解IoC的实现原理。

在对相关接口的实现函数进行源代码分析之前，首先说明下ContainerImpl类的一些与此相关的成员变量。

1、factories变量

final   Map<Key<?>, InternalFactory<?>>   factories ;

factories是在生成容器对象时传递进来的参数，在之前的博文《Struts2的Builder模式》中介绍了参数的收集过程，并且对参数的作用作了一定的介绍。这里再简要说明下，构造容器对象时传递进来的参数是<Key,InternalFactory>的键值对。Key代表的是一个对象的类型、类型的名称，InternalFactory代表的是创建一个具体对象的工厂对象，在需要的时候，调用factory方法就可以生成这个对象。

factories是在ContainerImpl类的构造函数中被赋值的，就是参数传递进来的值。

2、injectors变量

final   Map<Class<?>, List<Injector>>  injectors  =

  new   ReferenceCache<Class<?>, List<Injector>>()   {

       @Override

        protected   List<Injector> create( Class<?> key ) {

           List<Injector> injectors =  new   ArrayList<Injector>();

             addInjectors(key, injectors);

                 return   injectors;

     }

};

injectors实际上是一个ReferenceCache对象，就是在之前的博文《Struts2缓存解析》中分析的Struts2的一个缓存实现。这里是缓存了类和其注入器之间的关系。对ReferenceCache类的create函数的重写，主要是调用了ContainImpl类的addInjectors函数。这是实现缓存延迟加载原理中真正加载缓存对象的地方，在缓存中暂时找不到所要的对象时，就通过addInjectors来加载所需的对象。

addInjectors的代码如下

void   addInjectors(   Class   clazz, List<Injector> injectors ) {

                 if   (clazz == Object. class ) {

                        return ;

              }

              addInjectors(clazz.getSuperclass(), injectors);//递归向上，为其父类实现注入，直到遇到Object为止

               //变量注入

              addInjectorsForFields(clazz.getDeclaredFields(),   false , injectors);

               //方法注入

              addInjectorsForMethods(clazz.getDeclaredMethods(),   false , injectors);

       }

简单说来addInjectors的作用就是递归向上依次实现注入的动作，实现变量注入和方法注入。

这里看不到真正执行注入的动作，继续分析。来看addInjectorsForFields的代码

void   addInjectorsForFields( Field[] fields,   boolean   statics, List<Injector> injectors ) {

   addInjectorsForMembers(Arrays.   asList (fields), statics, injectors,

                 //匿名内部类，注意这个InjectorFactory对象

                  new   InjectorFactory<Field>() {

                   @Override

                     public   Injector create( ContainerImpl container, Field field, String name )

                                       throws  MissingDependencyException {

                          return   new   FieldInjector(container, field, name);//注意这里

                                  }

                  });

}

从代码上看，addInjectorsForFields也不是执行注入动作的地方，而是通过调用addInjectorsForMembers来实现。与此类似，对addInjectorsForMethods，也是通过调用addInjectorsInjectorsForMembers来执行注入的动作。也就是二者最终都汇集到了对一个方法的调用上，当主要的区别在于所传递的参数的不同之处。而影响最终注入动作的就是最后一个参数，InjectorFacotry对象。

区别点：

在addInjectorsForField中，这个InjectorFactory对象的create方法调用，返回的是一个FieldInjector对象；

在addInjectorsForMethods中，传递的InjectorFactory对象的create方法调用，返回的是一个MethodInjector对象。

下面来研究addInjectorsForMembers函数，

<M   extends   Member & AnnotatedElement>   void   addInjectorsForMembers(

                     List<M> members,   boolean   statics, List<Injector> injectors,

                     InjectorFactory<M> injectorFactory ) {

                 for   ( M member : members ) {

                        if   (isStatic(member) == statics) {

                              Inject   inject = member.getAnnotation(   Inject .   class );

                              if   (inject !=   null ) {

                                     try   {

                                            //inject.value()!!

                                         injectors.add(injectorFactory.create(   this , member, inject.value()));

                                  }   catch   ( MissingDependencyException e ) {

                                            if   (inject.required()) {

                                                   throw   new   DependencyException(e);

                                         }

                                  }

                           }

                     }

              }

       }

注意在addInjectors方法中调用addInjectorsForFields和addInjectorsForMethods时，传递了一个false参数，传递到addInjectorsForMembers时，就是这个statics参数为false。就是为其中非静态的实例变量和实例方法来实现注入。对于静态的类变量和类方法，这里不执行注入动作。关于静态的情况，这里就不做讨论了。。。

在上面的addInjectorForMembers方法中，主要看这两条语句

Inject  inject = member.getAnnotation(   Inject .   class   );首先获取这个成员（变量、方法）的注释情况，如果对这个成员有“@Inject”的注释，那么就执行这条语句injectors.add(injectorFactory.create(   this   , member, inject.value()));生成这个成员的注入器中，然后保存起来。

保存起来，保存到了何处？看整个调用过程， addInjectors(key,  injectors );->

   addInjectorsForFields(clazz.getDeclaredFields(),  false   ,  injectors );->

       addInjectorsForMembers(..., injectors ,...);

其实是保存在了由传进来的参数指定的List<Injector>中，也就是设置的缓存变量ReferenceCache类型的injectors中。再回过头来看

这个 ReferenceCache类型的injectors缓存，它是ReferenceCache<Class<?>,List<Injector>>，也就是通过类类型，来获取这个类的所有的注入器。

根据之前对缓存的讲解，当找不到缓存值时，就会实现加载，也就是调用create。将调用create的值返回，也就是那些生成的注入器了。具体说来，就是当通过injectors.get(XXX.class);针对这个类类型加载的注入器会被返回。也就是前面所说的保存的地方了！

[IoC的具体实现]

与Struts2的IoC相关的数据结构介绍完之后，现在来说下接口函数的实现，同时这里以对成员变量的注入为例，通过FieldInjector来看，注入操作到底做了什么。

首先来看 getInstance的实现。

其它的重载函数不予说明，这里给出的是真正执行动作的那个getInstance的实现。其它的重载函数最终都是通过对这个函数的调用来实现的。

<T> T getInstance( Class<T> type, String name, InternalContext context ) {

              ExternalContext<?> previous = context.getExternalContext();

              Key<T> key = Key.   newInstance (type, name);

              context.setExternalContext(ExternalContext.   newInstance (   null , key, this   ));

                 try   {

                        InternalFactory  o = getFactory(key);

                        if   (o !=  null   ) {

                              return   getFactory(key).create(context);

                     }  else   {

                              return   null   ;

                     }

              }  finally   {

                     context.setExternalContext(previous);

              }

       }

类容不长，真正要注意的地方就是这句话 return   getFactory(key).create(context);通过制定的类型和名称，来获取能够生成所需实例的工厂对象，其它的语句是对内外上下文的一些设置操作（内外上下文的具体差异，我也比较模糊）。

getFactory方法的方法体中，只有一句话

<T> InternalFactory<?  extends  T> getFactory( Key<T> key ) {

                 return   (InternalFactory<T>)  factories   .get(key);

       }

从上面的代码来看，对getInstance的实现是非常简单的，困难的过程是在于构造容器过程中收集参数的过程，在之前的一篇博文《Struts2的Builder模式》中有简单地介绍。

再来看inject的实现。

也是忽略其它重载函数，给出执行最终动作的inject函数的代码。inject方法的重载情况稍微复杂一点，有两条路，这里对与前面的内容相关的那一条路进行介绍。整个的代码如下

void   inject( Object o, InternalContext context ) {

              List<Injector> injectors =  this   . injectors   .get(o.getClass());

                 for   ( Injector injector : injectors ) {

                     injector.inject(context, o);

              }

       }

就是首先获取这个对象的所有注入器，然后依次执行注入操作。至于，具体的注入动作是做哪些事情，这里看不出来，要通过对注入器的研究来了解。前面的内容中总共出现过两类注入器FieldInjector和MethodInjector。这里以FieldInjector为例来进行分解。对这个类的核心方法进行研究，下面是FieldInjector类的inject函数的代码。其它部分的代码与注入功能的相关性不大，主要是做一些权限上的检查和设置，这里就不与列出了。

public   void   inject( InternalContext context, Object o ) {

                        //change the external context

                     ExternalContext<?> previous = context.getExternalContext();

                     context.setExternalContext(   externalContext   );

                        try   {

                              /*

                            * "factory.create()" method will create an instance of the source type,

                            * indicated by the value of the @Inject annotation

                            * set the field value

                            * */

                              field .set(o,  factory .create(context));

                     }  catch   ( IllegalAccessException e ) {

                              throw   new   AssertionError(e);

                     }  finally   {

                           context.setExternalContext(previous);

                     }

              }

在FieldInjector的构造函数中，需要传递三个参数，

  public   FieldInjector( ContainerImpl container, Field field, String name )

在构造函数中，对factory进行初始化

Key <?> key = Key.   newInstance (field.getType(), name);

factory  = container.getFactory(key);

注意看addInjectorsForMembers中所传递的参数，name参数对应的是inject.value(),也就是@Inject(value="xxxx")或@Inject("")所指定的名称。一般对应于struts.xml中配置的bean的名称。在对FieldInject例子来说，就是这个成员变量所将要真正对应的那个bean。

结合上面的代码来看，FieldInjector的inject方法的主要动作就是 field .set(o, factory .create(context));设置指定对象的某个成员变量的值。这个对象o就是通过inject入口传进来的对象了。

所以，对FieldInjector的inject函数做个小结，就是设置某一对象的标有“@Inject”注释的成员变量的值。

类似地，对MethodInjector的inject函数做个小结，就是调用某一对象的表用“@Inject”注释的成员函数。

那么在进行对象注入，也就是调用inject方法的时候，是设置该对象的加标注的成员变量的值，以及调用加标注的成员函数。