深入研究xwork（二）

下面说一下create(..)方法干些什么东东（我说的create(..)是这个哦new ContainerBuilder().factory(IPerson.class,Person.class).factory(IUserPerson.class,UserPerson.class).create(true)）

java 代码

final ContainerImpl container = new ContainerImpl(
     new HashMap<key>, InternalFactory>(factories));  </key>
 if (loadSingletons) {
   container.callInContext(new ContainerImpl.ContextualCallable<void>() {  </void>
     public Void call(InternalContext context) {
       for (InternalFactory factory : singletonFactories) {
         factory.create(context);
       }
       return null;
     }
   });
 }

首先它创建一个ContainerImpl对象，这个对象的创建过程会做很多很多的事情，一些需要依赖注入的东西会在这里完成还是前面说的，它并没有完成真正的依赖注入（对象都没有创建当然没法注入了），它只是完成依赖注入所需要的一些信息，当然它不只完成这些，我现在还有点迷糊，等过两天再好好整理这一块！！

java 代码

container.injectStatics(staticInjections);

这段代码是进行static field 和static method的注入，众所周知static是和对象无关的，所以可以在没有实例化对象前进行注入

java 代码

IUserPerson person=container.getInstance(IUserPerson.class);

这行代码就是实例化一个对象，这个过程会完成所有的真的依赖注入工作

在

container.getInstance(..)

这个方法中会调用如下一段代码

ExternalContext previous = context.getExternalContext();
   Key<t> key = Key.newInstance(type, name);  </t>
   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);
   }

在这里通过Key.newInstance(type, name);创建一个Key，这个Key的type和name和调用factory(..)时放到factories中的Key相对应，所以通过InternalFactory o = getFactory(key);这个方法就能得到前面在factory(..)中创建的InternalFactory对象，进而可以调用它的create(..)方法(个人觉得这个设计的很精妙！),我们再来重新看一下这个方法的实现

public T create(InternalContext context) {
  if (constructor == null) {
    this.constructor =
        context.getContainerImpl().getConstructor(implementation);
  }
  return (T) constructor.construct(context, type);
}

这段代码通过调用constructor.construct(context, type);来创建一个对象，并进行依赖注入，

Object construct(InternalContext context, Class<? super T> expectedType) {
   ConstructionContext<T> constructionContext =
       context.getConstructionContext(this);

   // We have a circular reference between constructors. Return a proxy.
   if (constructionContext.isConstructing()) {
     // TODO (crazybob): if we can't proxy this object, can we proxy the
     // other object?
     return constructionContext.createProxy(expectedType);
   }

   // If we're re-entering this factory while injecting fields or methods,
   // return the same instance. This prevents infinite loops.
   T t = constructionContext.getCurrentReference();
   if (t != null) {
     return t;
   }

   try {
     // First time through...
     constructionContext.startConstruction();
     try {
       Object[] parameters =
           getParameters(constructor, context, parameterInjectors);
       t = constructor.newInstance(parameters);
       constructionContext.setProxyDelegates(t);
     } finally {
       constructionContext.finishConstruction();
     }

     // Store reference. If an injector re-enters this factory, they'll
     // get the same reference.
     constructionContext.setCurrentReference(t);

     // Inject fields and methods.
     for (Injector injector : injectors) {
       injector.inject(context, t);
     }

     return t;
   } catch (InstantiationException e) {
     throw new RuntimeException(e);
   } catch (IllegalAccessException e) {
     throw new RuntimeException(e);
   } catch (InvocationTargetException e) {
     throw new RuntimeException(e);
   } finally {
     constructionContext.removeCurrentReference();
   }
 }

这就是xwork进行依赖注入的过程，写的比较粗浅（不过第一次写原创，还是鼓励一下），