Struts2容器详解---IoC源码分析


Struts2作为一个Web MVC框架，自身提供了一个IoC容器，实现对对象的生命周期管理，核心功能就是将对象注入到容器以及从容器中获取对象。通过对struts2容器的分析，学习和探讨一下IoC的思想。

Container接口定义

<span style="color:#000000;">package com.opensymphony.xwork2.inject;</span>

<span style="color:#000000;">public interface Container extends Serializable {

......

/* Injects dependencies into the fields and methods of an existing object.
void inject(Object o);

/* Creates and injects a new instance of type.
<T> T inject(Class<T> implementation);

/* Gets an instance of the given dependency which was declared in
<T> T getInstance(Class<T> type, String name);

/* Convenience method.
<T> T getInstance(Class<T> type);

......
}</span>

接口的定义很明确， Container是通过重载的inject方法实现对象的注入， 通过getInstance从容器中获取对象。

Container实现ContainerImpl

package com.opensymphony.xwork2.inject;

class ContainerImpl implements Container {
//key是对Class<T> 和Name的封装， factories维护着Key和Class类型的工厂
final Map<Key<?>, InternalFactory<?>> factories;
//factoryNamesByType维护着Class和Class类型实例名的映射
final Map<Class<?>, Set<String>> factoryNamesByType;

ContainerImpl( Map<Key<?>, InternalFactory<?>> factories ) {
this.factories = factories;
Map<Class<?>, Set<String>> map = new HashMap<Class<?>, Set<String>>();
for ( Key<?> key : factories.keySet() ) {
Set<String> names = map.get(key.getType());
if (names == null) {
names = new HashSet<String>();
map.put(key.getType(), names);
}
names.add(key.getName());
}

for ( Entry<Class<?>, Set<String>> entry : map.entrySet() ) {
entry.setValue(Collections.unmodifiableSet(entry.getValue()));
}

this.factoryNamesByType = Collections.unmodifiableMap(map);
}

<T> InternalFactory<? extends T> getFactory( Key<T> key ) {
return (InternalFactory<T>) factories.get(key);
}

/*Field and method 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;
}
};

void addInjectors( Class clazz, List<Injector> injectors ) {
if (clazz == Object.class) {
return;
}

// Add injectors for superclass first.
addInjectors(clazz.getSuperclass(), injectors);

// TODO (crazybob): Filter out overridden members.
addInjectorsForFields(clazz.getDeclaredFields(), false, injectors);
addInjectorsForMethods(clazz.getDeclaredMethods(), false, injectors);
}

void addInjectorsForMethods( Method[] methods, boolean statics, List<Injector> injectors ) {
addInjectorsForMembers(Arrays.asList(methods), statics, injectors,
new InjectorFactory<Method>() {
public Injector create( ContainerImpl container, Method method,
String name ) throws MissingDependencyException {
return new MethodInjector(container, method, name);
}
});
}

void addInjectorsForFields( Field[] fields, boolean statics,List<Injector> injectors ) {
addInjectorsForMembers(Arrays.asList(fields), statics, injectors,
new InjectorFactory<Field>() {
public Injector create( ContainerImpl container, Field field,String name ) throws MissingDependencyException {
return new FieldInjector(container, field, name);
}
});
}

<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 {
injectors.add(injectorFactory.create(this, member, inject.value()));
} catch ( MissingDependencyException e ) {
if (inject.required()) {
throw new DependencyException(e);
}
}
}
}
}
}

Container构建

DefaultConfiguration

reloadContainer方法中构建了两个Container，一个是bootstrap，主要完成对containerProvider的完整初始化，另外一个是全局的Container--container，即struts主要完成IoC的构件，它们的构建方法都一样，使用了构建模式，下面以container为例来分析。

ContainerBuilder builder = new ContainerBuilder();#创建ContainerBuiler
Container bootstrap = createBootstrapContainer(providers);
for (final ContainerProvider containerProvider : providers)
{
bootstrap.inject(containerProvider);
containerProvider.init(this);
containerProvider.register(builder, props);

#其中有BeanSelectionProvider，在dispatcher的init方法中调用init_AliasStandardObjects中加入providers中
}
props.setConstants(builder);

builder.factory(Configuration.class, new Factory<Configuration>() {
public Configuration create(Context context) throws Exception {
return DefaultConfiguration.this;
}
});

ActionContext oldContext = ActionContext.getContext();
try {
......
container = builder.create(false);#ContainerBuilder构建Container
setContext(container);
objectFactory = container.getInstance(ObjectFactory.class);
......

BeanSelectionProvider

register方法

public void register(ContainerBuilder builder, LocatableProperties props) {
alias(ObjectFactory.class, StrutsConstants.STRUTS_OBJECTFACTORY, builder, props);
alias(FileManagerFactory.class, StrutsConstants.STRUTS_FILE_MANAGER_FACTORY, builder, props, Scope.SINGLETON);
......
}
void alias(Class type, String key, ContainerBuilder builder, Properties props) {
alias(type, key, builder, props, Scope.SINGLETON);
}

alias方法

void alias(Class type, String key, ContainerBuilder builder, Properties props, Scope scope) {
if (!builder.contains(type)) {
......
builder.factory(type, cls, scope);
......
}
}

ContainerBuilder

public <T> ContainerBuilder factory(Class<T> type,
Class<? extends T> implementation, Scope scope) {
return factory(type, Container.DEFAULT_NAME, implementation, scope);
}

public <T> ContainerBuilder factory(final Class<T> type, final String name,
final Class<? extends T> implementation, final Scope scope) {
InternalFactory<? extends T> factory = new InternalFactory<T>() {
volatile ContainerImpl.ConstructorInjector<? extends T> constructor;
@SuppressWarnings("unchecked")
public T create(InternalContext context) {
if (constructor == null) {
this.constructor = context.getContainerImpl().getConstructor(implementation);
}
return (T) constructor.construct(context, type);//先得到类的构造器，再用构造器构造一个类的实例
}
......
};

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

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;
}

//用scopedFactory包装了一个factory,将对象工厂scopedFactory存放在factories中

Scope

SINGLETON {
@Override
<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;
}
}

@Override
public String toString() {
return factory.toString();
}
};
}
},

Singleton类型的scopeFactory内部保存一个T类型的实例，而create方法保证每次都返回同一个T实例，即单例T

THREAD {
@Override
<T> InternalFactory<? extends T> scopeFactory(Class<T> type, String name,
final InternalFactory<? extends T> factory) {
return new InternalFactory<T>() {
final ThreadLocal<T> threadLocal = new ThreadLocal<T>();
public T create(final InternalContext context) {
T t = threadLocal.get();
if (t == null) {
t = factory.create(context);
threadLocal.set(t);
}
return t;
}

@Override
public String toString() {
return factory.toString();
}
};
}
},

Thread类型的scopeFactory内部保存一个ThreadLocal<T>类型的实例，而create方法保证同一个线程每次都返回同一个T实例，即线程单例T

Container 构建--构建者模式

package com.opensymphony.xwork2.inject;

public final class ContainerBuilder {

final Map<Key<?>, InternalFactory<?>> factories =
new HashMap<Key<?>, InternalFactory<?>>();
final List<InternalFactory<?>> singletonFactories =
new ArrayList<InternalFactory<?>>();
......
public <T> ContainerBuilder factory(......
.....
public Container create(boolean loadSingletons) {
ensureNotCreated();
created = true;
final ContainerImpl container = new ContainerImpl(
new HashMap<Key<?>, InternalFactory<?>>(factories));
if (loadSingletons) {
container.callInContext(new ContainerImpl.ContextualCallable<Void>() {
public Void call(InternalContext context) {
for (InternalFactory<?> factory : singletonFactories) {
factory.create(context);
}
return null;
}
});
}
container.injectStatics(staticInjections);
return container;
}
}

一组重载的factory完成对factories的构建，create方法利用构建好的factories完成Container的创建。

Struts2框架内应用例子--ObjectFactory

在DefaultConfiguration.reloadContainer中
objectFactory = container.getInstance(ObjectFactory.class)

ContainerImpl

public <T> T getInstance( final Class<T> type ) {
return callInContext(new ContextualCallable<T>() {
public T call( InternalContext context ) {
return getInstance(type, context);
}
});
}

<T> T callInContext( ContextualCallable<T> callable ) {
Object[] reference = localContext.get();
if (reference[0] == null) {
reference[0] = new InternalContext(this);
try {
return callable.call((InternalContext) reference[0]);
} finally {
reference[0] = null;
localContext.remove();
}
} else {
return callable.call((InternalContext) reference[0]);
}
}

<T> T getInstance( Class<T> type, InternalContext context ) {
return getInstance(type, DEFAULT_NAME, context);
}

<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);
}
}

//首先通过getFactory(key)得到单例的scopeFactory，再调用scopeFactory的create去获取实例，如果实例不存在，再去调用scopeFactory包装的factory.create，即context.getContainerImpl().getConstructor(implementation);return (T) constructor.construct(context, type);

Struts2应用中Container的应用

Action中Inject业务逻辑类

public class LoginAction extends ActionSupport {
@Inject( "userService")
private UserService usersrv;

private String username;
private String password;

//省略get/set

public String login() {
UserInfo user = usersrv.getUser(username, password);
if (user != null) {
return SUCCESS;
}
return INPUT;
}
......
}

struts.xml

<struts>
<bean name="userService" type="com.struts.service.UserService" class="com.struts.service.UserService" />
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
<constant name="struts.devMode" value="true" />
<package name="default" extends="struts-default">
<default-action-ref name="index"/>

XmlConfigurationProvider

在struts初始化时，在DefaultConfiguration.reloadContainer中调用containerProvider.register(builder, props);

public void register(ContainerBuilder containerBuilder, LocatableProperties props) throws ConfigurationException {
......
for (Document doc : documents) {
......
if ("bean".equals(nodeName)) {
String type = child.getAttribute("type");
String name = child.getAttribute("name");
String impl = child.getAttribute("class");
......
try {
Class cimpl = ClassLoaderUtil.loadClass(impl, getClass());
Class ctype = cimpl;
......
cimpl.getDeclaredConstructors();
containerBuilder.factory(ctype, name, new LocatableFactory(name, ctype, cimpl, scope, childNode), scope);
}

//在解析struts.xml时，将bean的factory保存在ContainerImp中，将bean交给容器管理

DefaultActionInvocation

在struts2对url进行处理时，解析完url，分析完namespace, action, method后，创建完ActionProxyFactory,由ActionProxyFactory创建ActionInvocation，ActionProxy后，由DefaultActionInvocation创建Action

protected void createAction(Map<String, Object> contextMap) {
String timerKey = "actionCreate: " + proxy.getActionName();
try {
UtilTimerStack.push(timerKey);
action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
} catch
......

ObjectFactory

public Object buildAction(String actionName, String namespace, ActionConfig config, Map<String, Object> extraContext) throws Exception {
return buildBean(config.getClassName(), extraContext);
}

public Object buildBean(String className, Map<String, Object> extraContext) throws Exception {
return buildBean(className, extraContext, true);
}

public Object buildBean(String className, Map<String, Object> extraContext, boolean injectInternal) throws Exception {
Class clazz = getClassInstance(className);
Object obj = buildBean(clazz, extraContext);
//利用反射构建Action类实例
if (injectInternal) {
injectInternalBeans(obj);//IoC，注入依赖的Bean
}
return obj;
}

protected Object injectInternalBeans(Object obj) {
if (obj != null && container != null) {
container.inject(obj);
}
return obj;
}

ContainerImpl.inject

public void inject( final Object o ) {
callInContext(new ContextualCallable<Void>() {
public Void call( InternalContext context ) {
inject(o, context);
return null;
}
});
}

<T> T callInContext( ContextualCallable<T> callable ) {
Object[] reference = localContext.get();
if (reference[0] == null) {
reference[0] = new InternalContext(this);
try {
return callable.call((InternalContext) reference[0]);
} finally {
// Only remove the context if this call created it.
reference[0] = null;
// WW-3768: ThreadLocal was not removed
localContext.remove();
}
} else {
// Someone else will clean up this context.
return callable.call((InternalContext) reference[0]);
}
}

实际上会调用inject(object,InternalContext)
void inject( Object o, InternalContext context ) {
List<Injector> injectors = this.injectors.get(o.getClass());
for ( Injector injector : injectors ) {
injector.inject(context, o);
}
}
在injectors中找到Action类里面被@inject注释的field/method，然后执行field/mehtold的inject，在本例中是field被注解了
static class FieldInjector implements Injector {
......
public void inject( InternalContext context, Object o ) {
ExternalContext<?> previous = context.getExternalContext();
context.setExternalContext(externalContext);
try {
field.set(o, factory.create(context));//利用反射将对象的注解field设置成容器中管理对实例
} catch ( IllegalAccessException e ) {
throw new AssertionError(e);
} finally {
context.setExternalContext(previous);
}
}
}