Struts2依赖注入关联的类
?// ContainerImpl? 中定义的静态内部类
??
/** * Injects a field or method in a given object. */ interface Injector extends Serializable { void inject(InternalContext context, Object o); } static class MissingDependencyException extends Exception { MissingDependencyException(String message) { super(message); } }?? // 一些Injector 的实现类
static class FieldInjector implements Injector { final Field field; final InternalFactory<?> factory; final ExternalContext<?> externalContext; public FieldInjector(ContainerImpl container, Field field, String name) throws MissingDependencyException { this.field = field; field.setAccessible(true);// 此处貌似都是有必要的 //不使用构造函数是因为 Key类中构造函数定义为private Key<?> key = Key.newInstance(field.getType(), name); factory = container.getFactory(key);//注意传入ContainerImpl呀！ if (factory == null) { throw new MissingDependencyException( "No mapping found for dependency " + key + " in " + field + "."); } //不使用构造函数不知道为何了？？？？？ this.externalContext = ExternalContext.newInstance(field, key, container); } // 此处是核心关键调用的方法 public void inject(InternalContext context, Object o) { ExternalContext<?> previous = context.getExternalContext(); context.setExternalContext(externalContext); try { // 将指定对象变量上(o)此 Field 对象表示的字段设置为指定的新值(param2)。 field.set(o, factory.create(context)); } catch (IllegalAccessException e) { throw new AssertionError(e); } finally { // 此处谁能告诉我是干什么的？ context.setExternalContext(previous); } } }? //
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; } //member 反映有关单个成员（字段或方法）或构造方法的标识信息。 T inject(Member member, InternalContext context) { ExternalContext<?> previous = context.getExternalContext(); context.setExternalContext(externalContext); try { return factory.create(context); } finally { // 此处又来了 context.setExternalContext(previous); } } }? ?
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); } //内部类中提供的方法 @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(); } } }?// Container接口实现类中需要 重要的变量定义和方法定义
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]); } } // 注意此处的接口定义 interface ContextualCallable<T> { T call(InternalContext context); }?
?