Struts2源代码分析（二）类ContainerImpl的实现分析

要理解Struts2的源代码的一个核心是要理解它的对象容器的实现方式了。涉及的具体代码是接口com.opensymphony.xwork2.inject.Container.java，以及该接口的实现类com.opensymphony.xwork2.inject.ContainerImpl.java。在Struts2中容器的概念主要在于将使用了Inject注解的构造函数、方法和字段的依赖对象注入其中，方便在使用的时候直接从容器中取出对象。

以下为我对类ContainerImpl实现的理解，以注释的形式体现出来：

 /** * Copyright (C) 2006 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.opensymphony.xwork2.inject; import com.opensymphony.xwork2.inject.util.ReferenceCache; import java.lang.annotation.Annotation; import java.lang.reflect.AccessibleObject; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.Map.Entry; import java.io.Serializable; /** * Default {@link Container} implementation. * * @see ContainerBuilder * @author crazybob@google.com (Bob Lee) */ class ContainerImpl implements Container { /** * 将类型到该类型的构建工厂作为映射 */ final Map<Key<?>, InternalFactory<?>> factories; /** * 定义一个类型到名称集合的映射关系,一个类型对应于多个名称 */ 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); } /** * 根据类型来找到该类型的构造工厂类 * @param <T> 类型 * @param key 类型Key * @return */ @SuppressWarnings("unchecked") <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>>() { protected List<Injector> create(Class<?> key) { List<Injector> injectors = new ArrayList<Injector>(); addInjectors(key, injectors); return injectors; } }; /** * Recursively adds injectors for fields and methods from the given class to * the given list. Injects parent classes before sub classes. * */ 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 injectStatics(List<Class<?>> staticInjections) { final List<Injector> injectors = new ArrayList<Injector>(); for (Class<?> clazz : staticInjections) { addInjectorsForFields(clazz.getDeclaredFields(), true, injectors); addInjectorsForMethods(clazz.getDeclaredMethods(), true, injectors); } callInContext(new ContextualCallable<Void>() { public Void call(InternalContext context) { for (Injector injector : injectors) { injector.inject(context, null); } return null; } }); } /** * 找到对象所定义的全部方法，并且表示成注入器列表方式 * @param methods 方法列表 * @param statics 是否为静态 * @param 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); } }); } /** * 找到对象所定义的全部字段，并且表示成注入器列表方式 * @param fields 字段列表 * @param statics 是否为静态 * @param injectors 字段注入器列表，作为返回值 */ 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); } }); } /** * 找到类型的成员的注入器，以注解方式添加的 * @param <M> * @param members 类型的成员（字段或者方法） * @param statics 是否静态 * @param injectors 注入器列表，作为返回对象 * @param injectorFactory 注入器工厂 */ <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); } } } } } } /** * 注入器工厂 * @author zhangzk * * @param <M> */ interface InjectorFactory<M extends Member & AnnotatedElement> { Injector create(ContainerImpl container, M member, String name) throws MissingDependencyException; } /** * 检查成员是否为静态的 * @param member 字段和方法成员 * @return */ private boolean isStatic(Member member) { return Modifier.isStatic(member.getModifiers()); } /** * 字段属性注入器 * @author zhangzk * */ static class FieldInjector implements Injector { final Field field; /** * 类加载的时候需要注入的成员 */ final InternalFactory<?> factory; /** * 运行时需要注入的成员 */ final ExternalContext<?> externalContext; /** * * @param container 容器实例 * @param field 字段 * @param name 属性字段名称 * @throws MissingDependencyException */ public FieldInjector(ContainerImpl container, Field field, String name) throws MissingDependencyException { this.field = field; field.setAccessible(true); //构造属性KEY对象 Key<?> key = Key.newInstance(field.getType(), name); //在容器中找到构造该属性字段的构造工厂对象 factory = container.getFactory(key); if (factory == null) { throw new MissingDependencyException( "No mapping found for dependency " + key + " in " + field + "."); } //创建外部对象上下文 this.externalContext = ExternalContext.newInstance(field, key, container); } /** * 将传入的对象的字段设置值 * @param context 内部上下文 * @param o 传入对象 */ public void inject(InternalContext context, Object o) { ExternalContext<?> previous = context.getExternalContext(); context.setExternalContext(externalContext); try { field.set(o, factory.create(context)); } catch (IllegalAccessException e) { throw new AssertionError(e); } finally { context.setExternalContext(previous); } } } /** * Gets parameter injectors. * * @param member * to which the parameters belong * @param annotations * on the parameters * @param parameterTypes * parameter types * @return injections */ <M extends AccessibleObject & Member> ParameterInjector<?>[] getParametersInjectors( M member, Annotation[][] annotations, Class[] parameterTypes, String defaultName) throws MissingDependencyException { List<ParameterInjector<?>> parameterInjectors = new ArrayList<ParameterInjector<?>>(); Iterator<Annotation[]> annotationsIterator = Arrays.asList(annotations) .iterator(); for (Class<?> parameterType : parameterTypes) { Inject annotation = findInject(annotationsIterator.next()); String name = annotation == null ? defaultName : annotation.value(); Key<?> key = Key.newInstance(parameterType, name); parameterInjectors.add(createParameterInjector(key, member)); } return toArray(parameterInjectors); } <T> ParameterInjector<T> createParameterInjector(Key<T> key, Member member) throws MissingDependencyException { InternalFactory<? extends T> factory = getFactory(key); if (factory == null) { throw new MissingDependencyException( "No mapping found for dependency " + key + " in " + member + "."); } ExternalContext<T> externalContext = ExternalContext.newInstance( member, key, this); return new ParameterInjector<T>(externalContext, factory); } @SuppressWarnings("unchecked") private ParameterInjector<?>[] toArray( List<ParameterInjector<?>> parameterInjections) { return parameterInjections .toArray(new ParameterInjector[parameterInjections.size()]); } /** * Finds the {@link Inject} annotation in an array of annotations. */ Inject findInject(Annotation[] annotations) { for (Annotation annotation : annotations) { if (annotation.annotationType() == Inject.class) { return Inject.class.cast(annotation); } } return null; } /** * 方法注入器定义，负责以对象方法方式注入对象 * @author zhangzk * */ static class MethodInjector implements Injector { /** * 方法 */ final Method method; /** * 参数注入器 */ final ParameterInjector<?>[] parameterInjectors; public MethodInjector(ContainerImpl container, Method method, String name) throws MissingDependencyException { this.method = method; method.setAccessible(true); Class<?>[] parameterTypes = method.getParameterTypes(); if (parameterTypes.length == 0) { throw new DependencyException(method + " has no parameters to inject."); } parameterInjectors = container.getParametersInjectors(method, method.getParameterAnnotations(), parameterTypes, name); } public void inject(InternalContext context, Object o) { try { method.invoke(o, getParameters(method, context, parameterInjectors)); } catch (Exception e) { throw new RuntimeException(e); } } } Map<Class<?>, ConstructorInjector> constructors = new ReferenceCache<Class<?>, ConstructorInjector>() { @SuppressWarnings("unchecked") protected ConstructorInjector<?> create(Class<?> implementation) { return new ConstructorInjector(ContainerImpl.this, implementation); } }; /** * 构造函数注入器 * @author zhangzk * * @param <T> */ static class ConstructorInjector<T> { /** * 要处理的类型 */ final Class<T> implementation; /** * 需要注入的属性或者方法 */ final List<Injector> injectors; /** * 构造器 */ final Constructor<T> constructor; /** * 需要注入的参数数组 */ final ParameterInjector<?>[] parameterInjectors; ConstructorInjector(ContainerImpl container, Class<T> implementation) { this.implementation = implementation; constructor = findConstructorIn(implementation); constructor.setAccessible(true); try { //取得注解方式声明的注入依赖 Inject inject = constructor.getAnnotation(Inject.class); parameterInjectors = inject == null ? null // default // constructor. : container .getParametersInjectors(constructor, constructor.getParameterAnnotations(), constructor.getParameterTypes(), inject .value()); } catch (MissingDependencyException e) { throw new DependencyException(e); } injectors = container.injectors.get(implementation); } /** * 找到类型的构造器 * @param implementation 要处理的类型 * @return */ @SuppressWarnings("unchecked") private Constructor<T> findConstructorIn(Class<T> implementation) { Constructor<T> found = null; Constructor<T>[] declaredConstructors = (Constructor<T>[]) implementation .getDeclaredConstructors(); for (Constructor<T> constructor : declaredConstructors) { if (constructor.getAnnotation(Inject.class) != null) { if (found != null) { throw new DependencyException( "More than one constructor annotated" + " with @Inject found in " + implementation + "."); } found = constructor; } } if (found != null) { return found; } // If no annotated constructor is found, look for a no-arg // constructor // instead. try { return implementation.getDeclaredConstructor(); } catch (NoSuchMethodException e) { throw new DependencyException( "Could not find a suitable constructor" + " in " + implementation.getName() + "."); } } /** * 构造一个该对象实例或者是代理 * Construct an instance. Returns {@code Object} instead of {@code T} * because it may return a proxy. */ 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(); } } } /** * 参数注入器，表示以对象方法方式注入时的一个方法注入形式 * @author zhangzk * * @param <T> */ static class ParameterInjector<T> { /** * 外部上下文 */ final ExternalContext<T> externalContext; /** * 内部工厂 */ final InternalFactory<? extends T> factory; public ParameterInjector(ExternalContext<T> externalContext, InternalFactory<? extends T> factory) { this.externalContext = externalContext; this.factory = factory; } /** * 创建一个需要注入到方法参数的对象 * @param member 方法 * @param context 内部上下文 * @return 构造好的参数对象 */ T inject(Member member, InternalContext context) { ExternalContext<?> previous = context.getExternalContext(); context.setExternalContext(externalContext); try { return factory.create(context); } finally { context.setExternalContext(previous); } } } /** * 取得对象的方法的参数数组 * @param member 方法 * @param context 内部上下文 * @param parameterInjectors 参数的注入器数组 * @return 构造好的方法参数数组 */ private static Object[] getParameters(Member member, InternalContext context, ParameterInjector[] parameterInjectors) { if (parameterInjectors == null) { return null; } Object[] parameters = new Object[parameterInjectors.length]; for (int i = 0; i < parameters.length; i++) { parameters[i] = parameterInjectors[i].inject(member, context); } return parameters; } /** * 给对象注入其依赖的值或者对象 * @param o 需要注入属性或者对象的对象 * @param context 内部上下文 */ void inject(Object o, InternalContext context) { List<Injector> injectors = this.injectors.get(o.getClass()); for (Injector injector : injectors) { injector.inject(context, o); } } /** * 给对象注入其依赖的值或者对象 * @param <T> * @param implementation * @param context * @return */ <T> T inject(Class<T> implementation, InternalContext context) { try { ConstructorInjector<T> constructor = getConstructor(implementation); return implementation.cast(constructor.construct(context, implementation)); } catch (Exception e) { throw new RuntimeException(e); } } /** * 依照给定的类型和名称以及内部上下文创建对象的实例 * @param <T> 参数类型 * @param type 类型 * @param name 对象名称 * @param context 内部上下文 * @return 指定的参数类型的对象 */ @SuppressWarnings("unchecked") <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); } } /** * 依照给定的类型和默认名称以及内部上下文创建对象的实例 * @param <T> 参数类型 * @param type 类型 * @param context 内部上下文 * @return 指定的参数类型的对象 */ <T> T getInstance(Class<T> type, InternalContext context) { return getInstance(type, DEFAULT_NAME, context); } /** * Injects dependencies into the fields and methods of an existing object * 注入依赖到已经存在的对象的字段和方法 * @param implementation 类型 */ public void inject(final Object o) { callInContext(new ContextualCallable<Void>() { public Void call(InternalContext context) { inject(o, context); return null; } }); } /** * Creates and injects a new instance of type {@code implementation}. * 创建并且注入一个新的对应类型的实例 * @param implementation 类型 */ public <T> T inject(final Class<T> implementation) { return callInContext(new ContextualCallable<T>() { public T call(InternalContext context) { return inject(implementation, context); } }); } /** * Gets an instance of the given dependency which was declared in * 取得类型的实例对象 * @param type 类型 * @param name 配置的实例名称 */ public <T> T getInstance(final Class<T> type, final String name) { return callInContext(new ContextualCallable<T>() { public T call(InternalContext context) { return getInstance(type, name, context); } }); } /** * Convenience method. Equivalent to {@code getInstance(type,DEFAULT_NAME)}. * 根据默认名称来取得类型的实例对象（适用于一个类型创建一个默认对象的情况） * @param type 类型 */ public <T> T getInstance(final Class<T> type) { return callInContext(new ContextualCallable<T>() { public T call(InternalContext context) { return getInstance(type, context); } }); } /** * Gets a set of all registered names for the given type * 根据类型来取得该类型的实例对象名称集合（适用于同一个类型创建了多个不同名称的对象） * @param type 实例类型 */ public Set<String> getInstanceNames(final Class<?> type) { return factoryNamesByType.get(type); } /** * 本地线程上下文，保存内部上下文对象 */ ThreadLocal<Object[]> localContext = new ThreadLocal<Object[]>() { protected InternalContext[] initialValue() { return new InternalContext[1]; } }; /** * 在线程上下文中找内部上下文，找到则返回，否则重新创建一个 * Looks up thread local context. Creates (and removes) a new context if * necessary. */ <T> T callInContext(ContextualCallable<T> callable) { InternalContext[] reference = (InternalContext[]) localContext.get(); if (reference[0] == null) { reference[0] = new InternalContext(this); try { return callable.call(reference[0]); } finally { // Only remove the context if this call created it. reference[0] = null; } } else { // Someone else will clean up this context. return callable.call(reference[0]); } } /** * 线程本地上下文接口 * @author zhangzk * * @param <T> */ interface ContextualCallable<T> { /** * 取得内部上下文 * @param context * @return */ T call(InternalContext context); } /** * 根据给定的实现类来找到构造函数 * Gets a constructor function for a given implementation class. */ @SuppressWarnings("unchecked") <T> ConstructorInjector<T> getConstructor(Class<T> implementation) { return constructors.get(implementation); } /** * 作用域策略本地线程 */ final ThreadLocal<Object> localScopeStrategy = new ThreadLocal<Object>(); public void setScopeStrategy(Scope.Strategy scopeStrategy) { this.localScopeStrategy.set(scopeStrategy); } public void removeScopeStrategy() { this.localScopeStrategy.remove(); } /** * Injects a field or method in a given object. * 定义一个向对象中注入字段或者方法属性接口 */ interface Injector extends Serializable { void inject(InternalContext context, Object o); } /** * 失去依赖对象异常 * @author zhangzk * */ static class MissingDependencyException extends Exception { MissingDependencyException(String message) { super(message); } } } /** * Copyright (C) 2006 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.opensymphony.xwork2.inject; import com.opensymphony.xwork2.inject.util.ReferenceCache; import java.lang.annotation.Annotation; import java.lang.reflect.AccessibleObject; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; import java.lang.