Struts2 内部接口InternalFactory、ContextualCallable分析

在Struts2中,InternalFactory用于创建将被注入容器的对象

以struts配置中默认的bean为例:
a.向容器中注入bean对象
containerBuilder.factory(ctype, name, new LocatableFactory(name, ctype, cimpl, scope, childNode), scope);

b.从InternalContext中获取Context
public <T> ContainerBuilder factory(final Class<T> type, final String name,
final Factory<? extends T> factory, Scope scope) {
InternalFactory<T> internalFactory =
new InternalFactory<T>() {

public T create(InternalContext context) {
try {
Context externalContext = context.getExternalContext();
return factory.create(externalContext);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public String toString() {
return new LinkedHashMap<String, Object>() {{
put("type", type);
put("name", name);
put("factory", factory);
}}.toString();
}
};

return factory(Key.newInstance(type, name), internalFactory, scope);
}

3.向factories中注册InternalFactory
private <T> ContainerBuilder factory(final Key<T> key,
InternalFactory<? extends T> factory, Scope scope) {
ensureNotCreated();
checkKey(key);
final InternalFactory<? extends T> scopedFactory =
scope.scopeFactory(key.getType(), key.getName(), factory);
factories.put(key, scopedFactory);
if (scope == Scope.SINGLETON) {
singletonFactories.add(new InternalFactory<T>() {
public T create(InternalContext context) {
try {
context.setExternalContext(ExternalContext.newInstance(
null, key, context.getContainerImpl()));
return scopedFactory.create(context);
} finally {
context.setExternalContext(null);
}
}
});
}
return this;
}

4.单列模式
Scope.SINGLETON {
<T> InternalFactory<? extends T> scopeFactory(Class<T> type, String name,
final InternalFactory<? extends T> factory) {
return new InternalFactory<T>() {
T instance;
public T create(InternalContext context) {
synchronized (context.getContainer()) {
if (instance == null) {
instance = factory.create(context);
}
return instance;
}
}

public String toString() {
return factory.toString();
}
};
}
}

当要从容器中获取对象时，只需要给出类名即可
dispatcher.getContainer().getInstance(ValueStackFactory.class)

这样它会首先去调用SINGLETON的create方法，再调用3的InterFactory，最后调用我们最初传进来的Factory;这样做的好处在于它可以进行单例判断，增加内部上下文，把InternalFactory注册到Container等；

在getInstance的过程中，它同样使用了一些内部类ContextualCallable，因在ContainerImpl的很多方法都涉及到InternalContext参数赋值，所以它在callInContext中做了统一处理，而把变化的调用留给ContextualCallable接口去处理