SwiftSuspenders 1.6 浅出深入深入

破晓 · 发表于 2015-1-10 21:22:02

本系列文章来自:http://sswilliam.blog.163.com/blog/static/189696383201175114948372/

接上篇:SwiftSuspenders 1.6 浅出深入浅出

深入

这篇SwiftSuspenders 浅出深入的深入部分主要是对SwiftSuspenders进行深度剖析，包括对SwiftSuspenders的体系结构的分析，一个对象在整个注入过程中会经历怎样的生命周期，以及对SwiftSuspenders每个类的详细解读。

术语表

首先为了表达的明确性，先列下了一些可能在文章中用到的术语。这样便于减少理解上的歧义：

为了解释清楚术语之间的关系，我们设计以下场景以进行类比：闪闪同学生病了，需要进行打针治疗。

术语名	英文	解释
依赖	Dependency	面向对象中类之间的关系，简单来说，当A类的某些功能需要B类进行辅助时，就说A类对B类有依赖。如闪闪同学需要药来治病，那么就说闪闪对药有依赖
注入	Injection	一种建立依赖关系的行为。如闪闪同学要使用药，就必须让药进入体内(引用关系)。如何让药进入体内呢？需要一个针筒，通过注射来获得药物。这就是注入。当A和B的依赖关系由C来建立。B被C注入进了A。
注入器	Injector	就是SwiftSuspenders里面的Injector类的一个实例，相当于扮演针筒的角色。
注入配置	InjectionConfig	是针对一个注入行为的配置对象。包含注入请求的类和注入名。所使用的注入器和返回结果的策略等信息。如闪闪得的是感冒，需要注射感冒药，还需要注射消炎药，这时候闪闪就要请求两种类型的药。同一种类型的药，可能还有不同的品牌，所以有的时候还需要加上请求的药的名字，就相当于注入名。注入配置就相当于一张处方单。
注入点	InjectionPoint	依赖注入分几种形式，如，构造函数注入，属性注入和方法注入。这些都称做注入点。比如打针，可以打PP，也可以打胳膊。属性注入就是对public的属性或者有setter方法进行复制，方法注入就是像某个函数传参。
注入描述	InjecteeDescription	包含了一个被注入对象的所有的注入点。比如闪闪打针，需要在胳膊打一针，需要在屁股打两针。就会描述在注入描述里面。InjecteeDescription是Injector的一个包外类。
返回策略	InjectionResult	反应了注入器以何种方式对请求进行注入，如直接新建一个B对象，然后注入A，或者以单例模式新建一个B对象，然后所有使用B的注入都会共享同一个对象等等。

体系结构

SwiftSuspenders的类图如上图所示。整个框架以Injector为核心。InjectionPoint包中包含了所有与注入点相关的类，InjectionResult包中包含了返回策略相关的类。其他的类都是配合Injector类进行工作。具体的类的解读会在下一章进行深入介绍。

其中用到的设计模式主要有策略模式，模板方法。

在InjectionResult包中主要使用了通过策略模式，作者针对不同的需求创造了不同的映射策略，如单例模式，类模式，对象模式。同时还允许开发者开发其他所需的策略。

在InjectionPoint包中主要使用了模板方法，通过让不同的子类实现initializeInjection这个钩子(hook)方法从而实现不同的注入点

对象生命周期

这一章主要从内部分析SwiftSuspender的两个主要活动：映射和注入的流程

映射顺序图

以mapClass为例，首先主程序调用Injector的mapClass方法，传入所需的参数；

然后Injector调用自身的getMapping方法，获得一个相应的注入配置对象，如果再此之前已经建立过相应的注入配置，则直接返回，如果没有，就会新建一个注入配置对象

获得注入配置对象后，就会调用得到的InjectionConfig的setResult方法设置该配置的返回策略。如为类映射是，就设置为InjectClassResult。如果是单例，则设置为InjectSingletonResult。以此类推。

最后返回设置好各项参数的InjectionConfig。同时该InjectionConfig对象就会存在Injector的m_mappings的Dictionary中。整个映射的过程就完成了。

注入顺序图

通过Injector的getInstance()方法可以获得注入后的对象。主程序通过向Injector发送类+注入名的请求以获得对象。

Injector得到请求后，调用自身的getConfigurationForRequest()方法获得相应的InjectionConfig注入配置.

获得注入配置后，调用InjectionConfig的getResponse()方法获得结果。

InjectionConfig的getResponse()方法会调用相应的InjectionResult返回策略的getResponse()方法获得结果。如果traverseAncestors设为true，那么当在当前的注入器中没有找到相应的注入配置时，还会从下至上依次遍历其祖先注入器，直到找到位置。

InjectionResult会调用Injector的instantiate()方法获得对象。

在Injector的instantiate方法会调用Injector的getInjectionPoints方法获得需要注入的类的所有的注入点。然后调用构造函数注入点先获得所请求类的实例。

在得到请求类的实例后，Injector会调用自身的InjectInto方法像这个对象的其他注入点进行依赖注入。

最后将注入完成的结果返回给程序。在注入的过程中，如果遇到被注入的对象仍然需要依赖注入，就会和上面的流程一样，对被注入的对象同样执行依赖注入，然后再将注入完的对象注入进目标对象。

破晓 · 发表于 2015-1-10 21:24:17

类解读Injector

Injector是整个SwiftSuspenders框架的核心。与开发者打交道最多的也就是Injector类。Injector就是注入器，其功能相当于Spring里的ApplicationContext。是IOC容器。简单的理解可以将它理解为一个工厂，当开发者需要一个对象的时候，不是new出这个对象，而是通过Injector得到这个对象。Injector会自动完成返回的对象的依赖注入。

Injector的私有属性如下：

属性名	功能
INJECTION_POINTS_CACHE[static]:Dictionary	一个静态属性，缓存所有注入器的注入点描述。如果一个注入器通过xml来配置注入点，则不会和其他注入器共享注入点的缓存；如果不是通过xml来配置注入点，则会所有的注入器都共享注入点缓存，这也是基于性能的考虑。由于分析一个类的注入点需要通过describeType方法解析类的XML描述，如果两个注入器会映射相同的类，那么只需要解析一遍就可以了。注意：这个变量缓存的是类的注入点(InjectionPoints)信息而非注入配置(InjectionConfig)。注入器之间是不共享注入配置信息的。如A1注入器已经映射过一次B类，如果A2注入器再映射B类时，就直接使用A1注入器映射过的B类的注入点信息而不需要自己再一次运算了。因为同一个类的注入点一定是相同的。
m_parentInjector : Injector	父注入器的引用
m_applicationDomain: ApplicationDomain	注入器工作的应用程序域
m_mappings: Dictionary	存储所有该注的注入配置(InjectionConfig)
m_injecteeDescriptions: Dictionary	存储该注入器相关的的注入点描述。如果不是通过xml进行注入点配置的话，该属性指向INJECTION_POINTS_CACHE，即所有的注入器共享类的注入点信息
m_attendedToInjectees: Dictionary	存储已经注入过的对象。这样在下一次请求时，就不需要再执行注入操作。以提升性能。
m_xmlMetadata：XML	配置注入信息的XML文件。

Injector公有方法如下：

方法名	功能
Injector(xmlConfig : XML = null)	构造函数，初始化注入器的一些私有变量，如果是通过xml进行配置。就在参数里面写入。这样注入器就会设置为xml配置的模式。
mapValue(whenAskedFor : Class, useValue : Object, named : String = "") : *	值映射。将一个请求[类的全名+#+注入名映射为一个已有的对象
mapClass(whenAskedFor : Class, instantiateClass : Class, named : String = "") : *	类映射，将一个请求[类的全名+#+注入名映射为一个类。注意，被映射的类和请求的类可以毫无关系。
mapSingleton( whenAskedFor : Class, named : String = "") : *	单例映射，将一个请求[类的全名+#+注入名映射为该类的单例对象。
mapSingletonOf( whenAskedFor : Class, useSingletonOf : Class, named : String = "") : *	单例类映射，将一个请求[类的全名+#+注入名映射为另一个类的单例对象。注意，被映射的类和请求的类可以毫无关系。
mapRule(whenAskedFor : Class, useRule : , named : String = "") :	规则映射。将一个请求[类的全名+#+注入名映射另一个注入配置的返回策略(个人觉得这个方法其实没什么作用。还不如将第二个参数设为自定义的InjectionResult。这样还可以增加可扩展性)
getMapping (whenAskedFor : Class, named : String = "")	根据请求获得相应的注入配置。如果已有相应的注入配置，直接从mappings缓存里面返回，如果没有，则会新建一个相应的注入配置。然后保存在mapping中。
injectInto(target : Object):void	向目标对象进行依赖注入。(只包括属性注入和方法注入)。构造函数注入在生成目标对象时就已经完成了。
instantiate(clazz:Class):*	实例化一个类。会通过构造函数注入方法新建这个类，然后调用injectInto方法完成这个对象的依赖注入。最后返回完成注入的对象。
unmap(clazz : Class, named : String = ""):*	解除一个映射。内部只是将该映射的InjectionConfig的返回策略设为空。(个人认为应该还需要将mapping里面的引用删掉)。
hasMapping(clazz : Class, named : String = '') : Boolean	根据一个请求检测是否存在相应的注入配置(InjectionConfig)
getInstance(clazz : Class, named : String = '') : *	根据请求返回相应的实例。该实例已经完成所有的依赖注入。
createChildInjector(applicationDomain:ApplicationDomain=null) : Injector	创建子注入器
setApplicationDomain(applicationDomain:ApplicationDomain):void	设置注入器的应用程序域
getApplicationDomain():ApplicationDomain	获得注入器的应用程序域
setParentInjector(parentInjector : Injector)	设置注入器的父注入器
getParentInjector() : Injector	获得注入器的父注入器
purgeInjectionPointsCache()	清除注入点缓存。

Injector包内方法如下：

方法名	功能
getAncestorMapping( whenAskedFor : Class, named : String = null) : InjectionConfig	自下而上依次从父注入器获得请求的注入配置。直到找到为止。注意：只会寻找离当前注入器最近的注入配置。如A的父注入器是B，B的父注入器是C。B和C有相同请求名的注入配置。那么A只会使用B的注入配置。
get attendedToInjectees() : Dictionary	获得所有已经住如过的对象。

Injector的私有方法如下：

方法名	功能
getInjectionPoints(clazz : Class) : InjecteeDescription	获得一个类的注入描述(InjecteeDescription)。这个注入描述中包含了这个类所有的注入点信息。通过describeType方法获得这个类的XML表示。然后查找包含Inject元数据和PostConstruct元数据的节点来配置相应的注入点。最后封装到InjecteeDescription对象中
getConfigurationForRequest(clazz : Class, named : String, traverseAncestors : Boolean = true) : InjectionConfig	根据请求返回相应的注入配置(InjectionConfig)。traverseAncestors决定是会从父注入器中查找。
createInjectionPointsFromConfigXML(description : XML)	从xml中配置注入点信息。大体的流程是首先清除原来类中的所有元数据信息，然后根据配置的xml，重新添加新的元数据信息。
addParentInjectionPoints(description : XML, injectionPoints : Array) : void	从父类中找到注入点，然后添加进子类的注入点描述当中。因为子类也应该继承父类的注入点信息。

Injector包外类：InjecteeDescription

InjecteeDescription描述了一个类的注入点信息。内含两个公有属性：

属性名	功能
Ctor:InjectionPoint	构造函数注入点
injectionPoints :Array	属性，方法和PostConstruct注入点

破晓 · 发表于 2015-1-10 21:28:46

Injector类的完整注释如下：

/*
* Copyright (c) 2009-2010 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders
{
import flash.system.ApplicationDomain;
import flash.utils.Dictionary;
import flash.utils.Proxy;
import flash.utils.describeType;
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;
import org.swiftsuspenders.injectionpoints.ConstructorInjectionPoint;
import org.swiftsuspenders.injectionpoints.InjectionPoint;
import org.swiftsuspenders.injectionpoints.MethodInjectionPoint;
import org.swiftsuspenders.injectionpoints.NoParamsConstructorInjectionPoint;
import org.swiftsuspenders.injectionpoints.PostConstructInjectionPoint;
import org.swiftsuspenders.injectionpoints.PropertyInjectionPoint;
import org.swiftsuspenders.injectionresults.InjectClassResult;
import org.swiftsuspenders.injectionresults.InjectOtherRuleResult;
import org.swiftsuspenders.injectionresults.InjectSingletonResult;
import org.swiftsuspenders.injectionresults.InjectValueResult;
/**
* Injector注入器,即IOCcontainer，相当于Spring里面的ApplicationContext
* 类似于工厂，通过注册类来获取实例，同时会添加实例的依赖
* 通过Injector获得的对象已经完成了依赖注入
*/
public class Injector
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
/**
* 注入点缓存
* 静态的缓存
* */
private static var INJECTION_POINTS_CACHE : Dictionary = new Dictionary(true);
/**
* 父注入器(Injector)对象
* */
private var m_parentInjector : Injector;
/**
* 注入器(Injector)对象的应用用程序域(ApplicationDomain)
* */
private var m_applicationDomain:ApplicationDomain;
/**
* [类的全名+#+注入名]与注入配置对象(InjectorConfig)的映射
* key是[类的全名+#+注入名]
* value是InjectionConfig对象
* 用来存储该注入器(Injector)所有的注入配置(InjectorConfig)
* */
private var m_mappings : Dictionary;
/**
* 注入描述对象字典,key为[class+name],value为InjectionConfig对象
*
* */
private var m_injecteeDescriptions : Dictionary;
/**
* 已经注入过的对象映射字典
* 采用Dictionary的原因是Dictionary采用===来比较，是根据对象来比较而不是根据toString();
* 这样是将对象和对象的注入描述进行映射
*
* */
private var m_attendedToInjectees : Dictionary;
/**
* 注入描述xml，在[Inject]元数据不支持时使用
* */
private var m_xmlMetadata : XML;
/*******************************************************************************************
* public methods *
*******************************************************************************************/
/**
* 构造函数
* @param xmlConfig - xml配置文件，可以通过外部xml来进行注入器(Injector)的注入的配置，弥补[Inject]无法使用情况,默认是null
* */
public function Injector(xmlConfig : XML = null)
{
m_mappings = new Dictionary();//初始化m_mappings
if (xmlConfig != null)//如果有配置文件
{
m_injecteeDescriptions = new Dictionary(true);//m_injecteeDescriptions注入描述字典对象新建为Injector对象的动态字典对象
}
else//如果没有配置文件
{
m_injecteeDescriptions = INJECTION_POINTS_CACHE;//m_injecteeDescriptions注入描述字典对象使用Injector的类的静态字典对象，这样多个注入器（Injector）共享同一个
}
m_attendedToInjectees = new Dictionary(true);//初始化m_attendedToInjectees对象
m_xmlMetadata = xmlConfig;//初始化xml元数据对象
}
/**
* 将类映射到一个对象，这样在请求[class+name]的时候，就会返回指定的对象
* @param whenAskedFor - 请求的类
* @param useValue - 请求类时返回的对象
* @named named - 注入名，对类进一步区分，[whenAskedFor的全名+'#'+named]是映射的key
*
* @return 返回一个结果策略为InjectValueResult的注入配置(InjectionConfig)对象
*
*
*/
public function mapValue(whenAskedFor : Class, useValue : Object, named : String = "") : *
{
var config : InjectionConfig = getMapping(whenAskedFor, named);//根据[class的全名+name]从m_mappings中获取一个注入配置(InjectionConfig)对象,
//getMapping(whenAskedFor, named)方法会根据[class的全名+name]检测m_mappings中是否有相应的注入配置(InjectionConfig)对象
//如果有直接从m_mappings返回
//如果没有，则新建一个注入配置(InjectionConfig)对象，然后存储在m_mappings，然后返回
config.setResult(new InjectValueResult(useValue));//设置获得的注入配置(InjectionConfig)对象注入结果(InjectionResult)策略，此处设置的是InjectValueResult策略。
return config;//返回注入配置(InjectionConfig)对象
}
/**
* 将A类映射到B类，这样在请求A类+name的时候，就会返回指一个B类对象的实例
* @param whenAskedFor - 请求的类
* @param instaniateClass - 返回对象的类
* @named named - 注入名，对类进一步区分，[whenAskedFor的全名+'#'+named]是映射的key
*
* @return 返回一个结果策略为InjectClassResult的注入配置(InjectionConfig)对象
*/
public function mapClass(
whenAskedFor : Class, instantiateClass : Class, named : String = "") : *
{
var config : InjectionConfig = getMapping(whenAskedFor, named);//根据[class的全名+name]从m_mappings中获取一个注入配置(InjectionConfig)对象
config.setResult(new InjectClassResult(instantiateClass));//设置获得的注入配置(InjectionConfig)对象注入结果(InjectionResult)策略，此处设置的是InjectClassResult策略。
return config;//返回注入配置(InjectionConfig)对象
}
/**
* 设置A类到A类的单例映射，这样在通过[askforclass+name]请求对象时的时候，就会返回一个A类的单例对象
* @param whenAskedFor - 请求的类
* @named named - 注入名，对类进一步区分，[whenAskedFor的全名+'#'+named]是映射的key
*
* @return 返回一个结果策略为InjectSingletonResult的注入配置(InjectionConfig)对象
*/
public function mapSingleton(whenAskedFor : Class, named : String = "") : *
{
return mapSingletonOf(whenAskedFor, whenAskedFor, named);//调用mapSingletonOf方法，mapSingletonOf可以设置A类到B类的单例映射
//即请求[A类的全名+name]时，返回的是B类的单例对象
}
/**
* 设置A类到B类的单间映射，这样在通过[askforclass+name]请求对象时的时候，就会返回一个B类的单例对象
* @param whenAskedFor - 请求的类
* @param useSingletonOf - 返回对象的类
* @named named - 注入名，对类进一步区分，[whenAskedFor的全名+'#'+named]是映射的key
*
* @return 返回一个结果策略为InjectSingletonResult的注入配置(InjectionConfig)对象
*/
public function mapSingletonOf(
whenAskedFor : Class, useSingletonOf : Class, named : String = "") : *
{
var config : InjectionConfig = getMapping(whenAskedFor, named);//根据[class的全名+name]从m_mappings中获取一个注入配置(InjectionConfig)对象
config.setResult(new InjectSingletonResult(useSingletonOf));//设置获得的注入配置(InjectionConfig)对象注入结果(InjectionResult)策略，此处设置的是InjectSingletonResult策略。
return config;//返回注入配置(InjectionConfig)对象
}
/**
* 设置类到自定义规则的映射
* @param whenAskedFor - 请求的类
* @param useRule - 自定义的规则
* @named named - 注入名，对类进一步区分，[whenAskedFor的全名+'#'+named]是映射的key
*
* @return 返回一个结果策略为InjectOtherRuleResult的注入配置(InjectionConfig)对象
* 在具体实现时会扩展InjectOtherRuleResult类
*/
public function mapRule(whenAskedFor : Class, useRule : *, named : String = "") : *
{
var config : InjectionConfig = getMapping(whenAskedFor, named);
config.setResult(new InjectOtherRuleResult(useRule));
return useRule;
}
/**
* 获得一个InjectionConfig注入配置对象
* */
public function getMapping(whenAskedFor : Class, named : String = "") : InjectionConfig
{
var requestName : String = getQualifiedClassName(whenAskedFor);//获得wenAskedFor类的全名，即[包名::类名]
//如trace(getQualifiedClassName(Sprite));
//返回flash.display::Sprite
var config : InjectionConfig = m_mappings[requestName + '#' + named];
if (!config)
{
config = m_mappings[requestName + '#' + named] =
new InjectionConfig(whenAskedFor, named);
}
return config;
}
/**
* 向目标注入
* @param - target 目标
* */
public function injectInto(target : Object) : void
{
if (m_attendedToInjectees[target])//m_attendedToInjectee中是否有这个对象
{
return;//如果有则返回,说明已经注入过了
}
m_attendedToInjectees[target] = true;//如果没有，说明没有注入过，开始注入
//get injection points or cache them if this target's class wasn't encountered before
var targetClass : Class = getConstructor(target);//获取目标的类
var injecteeDescription : InjecteeDescription =
m_injecteeDescriptions[targetClass] || getInjectionPoints(targetClass);//获取目标类的InjecteeDescription对象，
var injectionPoints : Array = injecteeDescription.injectionPoints;//获取注入点列表
var length : int = injectionPoints.length;
for (var i : int = 0; i < length; i++)//遍历注入点列表
{
var injectionPoint : InjectionPoint = injectionPoints[i];//针对每一个注入点
injectionPoint.applyInjection(target, this);//向目标注入
}
}
/**
* 实例化一个类，包括注入
* @param clazz，需要实例化的类
* */
public function instantiate(clazz:Class):*
{
var injecteeDescription : InjecteeDescription = m_injecteeDescriptions[clazz];//查找要注入的类的注入描述
if (!injecteeDescription)//如果没有
{
injecteeDescription = getInjectionPoints(clazz);//生成要注入类的注入描述
}
var injectionPoint : InjectionPoint = injecteeDescription.ctor;//获取要注入类的构造函数注入点
var instance : * = injectionPoint.applyInjection(clazz, this);//应用构造函数注入点
injectInto(instance);//对要注入类进行注入
return instance;//返回注入的结果
}
/**
* 解除一个映射
* @param clazz，请求的类
* @param named：注入名
* */
public function unmap(clazz : Class, named : String = "") : void
{
var mapping : InjectionConfig = getConfigurationForRequest(clazz, named);//根据请求查询相应的注入配置(InjectionConfig)
if (!mapping)//如果没有找到
{
throw new InjectorError('Error while removing an injector mapping: ' +
'No mapping defined for class ' + getQualifiedClassName(clazz) +
', named "' + named + '"');//抛出异常
}
mapping.setResult(null);//如果找到，直接将该注入配置的返回策略(InjectionResult)设为null。个人认为应该还需要从mappings中删除
}
/**
* 根据请求查询是否有相应的注入配置
* @param clazz，请求的类
* @param named：注入名
*
* @return 查询的结果
* */
public function hasMapping(clazz : Class, named : String = '') : Boolean
{
var mapping : InjectionConfig = getConfigurationForRequest(clazz, named);////根据请求查询相应的注入配置(InjectionConfig)
if (!mapping)//如果没有找到
{
return false;//返回false
}
return mapping.hasResponse(this);//如果找到，还需要检查这个注入配置是否有返回策略。
}
/**
* 从Ioc容器获得实例
* @param clazz，请求的类
* @param named：注入名
*
* @return：返回请求的对象，该对象已经完成了依赖注入
* */
public function getInstance(clazz : Class, named : String = '') : *
{
var mapping : InjectionConfig = getConfigurationForRequest(clazz, named);//获取InjectionConfig对象
if (!mapping || !mapping.hasResponse(this))//如果没有映射或者映射没有设置返回策略
{
throw new InjectorError('Error while getting mapping response: ' +
'No mapping defined for class ' + getQualifiedClassName(clazz) +
', named "' + named + '"');//抛出异常
}
return mapping.getResponse(this);//根据注入配置的返回策略返回相应的值
}
/**
* 创建子入器
* @param applicationDomain
* @param named：注入名
*
* @return：创建的子注入器
* * */
public function createChildInjector(applicationDomain:ApplicationDomain=null) : Injector
{
var injector : Injector = new Injector();//新建一个注入器
injector.setApplicationDomain(applicationDomain);//设置注入器的应用程序域
injector.setParentInjector(this);//将子注入器的父注入器设为自身
return injector;//返回新建的子注入器
}
/**
* 设置应用程序域
* @param applicationDomain
*
* * */
public function setApplicationDomain(applicationDomain:ApplicationDomain):void
{
m_applicationDomain = applicationDomain;//将m_applicationDomain赋值
}
/**
* 获得应用程序域
* @return 返回该注入器工作的应用程序域
*
* * */
public function getApplicationDomain():ApplicationDomain
{
return m_applicationDomain ? m_applicationDomain : ApplicationDomain.currentDomain;//如果m_applicationDomain不为null，返回m_applicationDomain
//如果m_applicationDomain为null，返回当前的与
}
/**
* 设置父注入器
* @param parentInjector 父注入器
* * */
public function setParentInjector(parentInjector : Injector) : void
{
//restore own map of worked injectees if parent injector is removed
if (m_parentInjector && !parentInjector)//如果m_parentInjectoru不为空，即已经设置过父注入器了，且当前传入的父注入器也不为空，即需要替换父注入器
{
m_attendedToInjectees = new Dictionary(true);//清空已经住如果的对象的缓存
}
m_parentInjector = parentInjector;//将m_parentInjector赋值为新的父注入器
//use parent's map of worked injectees
if (parentInjector)//如果赋值的新注入器不为空
{
m_attendedToInjectees = parentInjector.attendedToInjectees;//将当前注入器的注入对象缓存设为父注入器的注入对象缓存。
}
}
/**
* 获取父注入器
* @return parentInjector 父注入器
* * */
public function getParentInjector() : Injector
{
return m_parentInjector;
}
/**
* 清除注入点缓存
* 将INJECTION_POINTS_CACHE重新赋值
* */
public static function purgeInjectionPointsCache() : void
{
INJECTION_POINTS_CACHE = new Dictionary(true);//清空
}
/*******************************************************************************************
* internal methods *
*******************************************************************************************/
/**
* 根据请求，获取父注入器的注入配置
* @param whenAskedFor 请求的类
* @param named：注入名
*
* @return 查找到的注入配置
* * */
internal function getAncestorMapping(
whenAskedFor : Class, named : String = null) : InjectionConfig
{
var parent : Injector = m_parentInjector;//获得父注入器
while (parent)//遍历所有的父注入器
{
var parentConfig : InjectionConfig =
parent.getConfigurationForRequest(whenAskedFor, named, false);//从父注入器中查询相应的注入配置
if (parentConfig && parentConfig.hasOwnResponse())//如果存在注入配置且该注入配置有返回策略
{
return parentConfig;//返回注入配置，查询解除
}
parent = parent.getParentInjector();//如果没找到，继续遍历上一个父注入器
}
return null;//如果都没有，返回null
}
/**
* 获得注入过的对象的缓存
*
* @return 返回所有住如果的对象
* * */
internal function get attendedToInjectees() : Dictionary
{
return m_attendedToInjectees;//返回 m_attendedToInjectees
}
/*******************************************************************************************
* private methods *
*******************************************************************************************/
/**
* 获取一个类的注入点
* @param clazz，需要获取注入点的类
* 返回一个InjecteeDescription对象来描述所有的注入点
* */
private function getInjectionPoints(clazz : Class) : InjecteeDescription
{
var description : XML = describeType(clazz);//获取clazz的xml描述类型
if (description.@name != 'Object' && description.factory.extendsClass.length() == 0)//如果name属性不是Object且description.factory.extendsClass的长度为0,即clazz是一个接口
{
throw new InjectorError('Interfaces can\'t be used as instantiatable classes.');//抛出异常，接口不能被注入
/**
* 如果是一个接口，如IEventDispatcher
*
<type name="flash.events::IEventDispatcher" base="Class" isDynamic="true" isFinal="true" isStatic="true">
<extendsClass type="Class"/>
<extendsClass type="Object"/>
<accessor name="prototype" access="readonly" type="*" declaredBy="Class"/>
<factory type="flash.events::IEventDispatcher">
<method name="willTrigger" declaredBy="flash.events::IEventDispatcher" returnType="Boolean" uri="flash.events:IEventDispatcher">
<parameter index="1" type="String" optional="false"/>
</method>
<method name="dispatchEvent" declaredBy="flash.events::IEventDispatcher" returnType="Boolean" uri="flash.events:IEventDispatcher">
<parameter index="1" type="flash.events::Event" optional="false"/>
</method>
<method name="addEventListener" declaredBy="flash.events::IEventDispatcher" returnType="void" uri="flash.events:IEventDispatcher">
<parameter index="1" type="String" optional="false"/>
<parameter index="2" type="Function" optional="false"/>
<parameter index="3" type="Boolean" optional="true"/>
<parameter index="4" type="int" optional="true"/>
<parameter index="5" type="Boolean" optional="true"/>
</method>
<method name="hasEventListener" declaredBy="flash.events::IEventDispatcher" returnType="Boolean" uri="flash.events:IEventDispatcher">
<parameter index="1" type="String" optional="false"/>
</method>
<method name="removeEventListener" declaredBy="flash.events::IEventDispatcher" returnType="void" uri="flash.events:IEventDispatcher">
<parameter index="1" type="String" optional="false"/>
<parameter index="2" type="Function" optional="false"/>
<parameter index="3" type="Boolean" optional="true"/>
</method>
</factory>
</type>
* 以上为返回值factory.extendsClass为0
*
* 如果是一个Object
*
<type name="Object" base="Class" isDynamic="true" isFinal="true" isStatic="true">
<extendsClass type="Class"/>
<extendsClass type="Object"/>
<constant name="length" type="int"/>
<accessor name="prototype" access="readonly" type="*" declaredBy="Class"/>
<factory type="Object"/>
</type>
* factory.extendsClass为0且@name为Object
* 其他对象都不会
* 故这种方法可以判断是否为接口
* */
}
var injectionPoints : Array = [];//注入点列表
var node : XML;//节点
// This is where we have to wire in the XML...
if(m_xmlMetadata)//如果有预先设置了，m_xmlMetadata
{
createInjectionPointsFromConfigXML(description);//调用createInjectionPointsFromConfigXML方法
//传输这个类的description XML的目的在于需要清除所有的元数据标签，从而只从XML中进行配置
addParentInjectionPoints(description, injectionPoints);//继续添加父类的注入点。因为元数据标签的消失，所以需要遍历所有的父类。
//如果不使用m_xmlMetadata，元数据会自动被子类继承，则无需使用这一步
}
//get constructor injections
var ctorInjectionPoint : InjectionPoint;//构造函数注入点
node = description.factory.constructor[0];
if (node)//如果有description.factory.constructor
{
ctorInjectionPoint = new ConstructorInjectionPoint(node, clazz, this);//新建一个有参数的构造函数注入点
}
else
{
ctorInjectionPoint = new NoParamsConstructorInjectionPoint();//构造函数注入点为NoParamsConstructorInjectionPoint对象，即无参数的构造函数注入点对象
}
var injectionPoint : InjectionPoint;//申明注入点
//get injection points for variables
for each (node in description.factory.*.
(name() == 'variable' || name() == 'accessor').metadata.(@name == 'Inject'))//对于variable或者accessor结点中metadata的name是Inject的节点
{
injectionPoint = new PropertyInjectionPoint(node);//注入点为PropertyInjectionPoint对象，即属性注入点对象
injectionPoints.push(injectionPoint);//在注入点队列中添加改注入点
}
//get injection points for methods
for each (node in description.factory.method.metadata.(@name == 'Inject'))//遍历所有的Method节点中name为Inject的
{
injectionPoint = new MethodInjectionPoint(node, this);//注入点为MethodInjectionPoint对象，即方法注入点
injectionPoints.push(injectionPoint);//在注入点队列中添加该注入点
}
//get post construct methods
var postConstructMethodPoints : Array = [];//post Construct 方法注入点
for each (node in description.factory.method.metadata.(@name == 'PostConstruct'))//遍历所有PostConstruct的方法
{
injectionPoint = new PostConstructInjectionPoint(node, this);//以node新建一个PostConstructInjectionPoint对象
postConstructMethodPoints.push(injectionPoint);//将PostConstructInjectionPoint对象加入到postConstructMethodPoints postConstruct方法注入点列表中。
}
if (postConstructMethodPoints.length > 0)//如果有PostConstructInjectionPoint注册点
{
postConstructMethodPoints.sortOn("order", Array.NUMERIC);//根据order属性采用数值进排序
injectionPoints.push.apply(injectionPoints, postConstructMethodPoints);//将排序后的postConstructMethodPoinst添加到注入点中
/**
* 上面这种写法是将postConstructMethodPoints中的每一个值push到injectionPoints中,此时injectionPoints的长度是增加postConstructMethodPoints.length
* 如果直接injectionPoints.push(postConstructMethodPoints)就是将整个postConstructMethodPoints push进去,此时injectionPoints的长度是增加1
* */
}
var injecteeDescription : InjecteeDescription =
new InjecteeDescription(ctorInjectionPoint, injectionPoints);//生成该类注入点描述对象
m_injecteeDescriptions[clazz] = injecteeDescription;//在m_injecteeDescriptions中将该类和其注入点描述对象进行映射
return injecteeDescription;//返回注入点描述文件
}
/**
* 根据请求获得相应的注入配置
*
* @param clazz 请求的类
* @param named 注入名
* @param traverseAncestors 是否遍历父注入器
*
* @return 返回找到的注入配置
* */
private function getConfigurationForRequest(
clazz : Class, named : String, traverseAncestors : Boolean = true) : InjectionConfig
{
var requestName : String = getQualifiedClassName(clazz);//获取类名
var config:InjectionConfig = m_mappings[requestName + '#' + named];//获取映射
if(!config && traverseAncestors &&
m_parentInjector && m_parentInjector.hasMapping(clazz, named))//如果没有映射
{
config = getAncestorMapping(clazz, named);//从辅助器中进行遍历
}
return config;//返回映射
}
/**
* 从配置的XML中获取注入点
* 先擦出所有的元数据信息，然后再根据xml写入相应的元数据
* @param description 类的描述信息
* */
private function createInjectionPointsFromConfigXML(description : XML) : void
{
var node : XML;
//first, clear out all "Inject" metadata, we want a clean slate to have the result
//work the same in the Flash IDE and MXMLC
for each (node in description..metadata.(@name=='Inject' || @name=='PostConstruct'))//遍历类的描述XML中所有的name为Inject和PostConstruct的节点
{
delete node.parent().metadata.(@name=='Inject' || @name=='PostConstruct')[0];//清空这些节点，应为现在要根据xml来配置注入点，所以要消除元数据注入点的干扰
}
//now, we create the new injection points based on the given xml file
var className:String = description.factory.@type;//获取类名
for each (node in m_xmlMetadata.type.(@name == className).children())//遍历配置XML中有关这个类的节点的所有子节点
{
var metaNode : XML = <metadata/>;//新建一个metadata节点
if (node.name() == 'postconstruct')//如果name是postconstruct
{
metaNode.@name = 'PostConstruct';//新建节点的name设为PostConstruct
if (node.@order.length())
{
metaNode.appendChild(<arg key='order' value={node.@order}/>);//添加postConstruct的数据
}
}
else//如果不是postconstrut
{
metaNode.@name = 'Inject';//新建节点的name设为Inject
if (node.@injectionname.length())//如果有注入名
{
metaNode.appendChild(<arg key='name' value={node.@injectionname}/>);//添加注入名
}
for each (var arg : XML in node.arg)
{
metaNode.appendChild(<arg key='name' value={arg.@injectionname}/>);//添加Inject数据
}
}
var typeNode : XML;
if (node.name() == 'constructor')//如果name为constuctor
{
typeNode = description.factory[0];//将整个节点赋值给typeNode
}
else//如果不是
{
typeNode = description.factory.*.(attribute('name') == node.@name)[0];//将同名的节点赋值给typeNode
if (!typeNode)//如果也没有
{
throw new InjectorError('Error in XML configuration: Class "' + className +
'" doesn\'t contain the instance member "' + node.@name + '"');//抛出异常
}
}
typeNode.appendChild(metaNode);//添加元数据节点
}
}
/**
* 添加父类的注入点
*
* */
private function addParentInjectionPoints(description : XML, injectionPoints : Array) : void
{
var parentClassName : String = description.factory.extendsClass.@type[0];//获取父类的类名
if (!parentClassName)//如果没有则返回
{
return;
}
//如果有付烈
var parentClass : Class = Class(getDefinitionByName(parentClassName));//通过反射获得父类
var parentDescription : InjecteeDescription =
m_injecteeDescriptions[parentClass] || getInjectionPoints(parentClass);//获得父类的注入点
var parentInjectionPoints : Array = parentDescription.injectionPoints;
injectionPoints.push.apply(injectionPoints, parentInjectionPoints);//点加到子类的注入点中。
}
}
}
import org.swiftsuspenders.injectionpoints.InjectionPoint;
/**
* 注入员描述类
* */
final class InjecteeDescription
{
/**
* 构造函数注入点
* */
public var ctor : InjectionPoint;
/**
* 属性或方法注入点
* */
public var injectionPoints : Array;
public function InjecteeDescription(ctor : InjectionPoint, injectionPoints : Array)
{
this.ctor = ctor;//构造函数注入点
this.injectionPoints = injectionPoints;//剩余的属性和方法注入点
}
}

复制代码

破晓 · 发表于 2015-1-10 21:30:39

InjectionConfig

InjectionConfig是注入配置类，负责存储一个映射的相关信息，如请求的类，注入名，工作的注入器和结果返回策略等。通过注入器的mapClass等方法就会新建一个注入配置。并且注入器会缓存这些注入配置。从而在需要时调用以获得相应的对象。

InjectionConfig公共属性如下：

属性名	功能
request : Class	请求的类
injectionName : String	注入名

InjectionConfig以[类的全名+#+注入名作为唯一的标识。类的全名就是包名::类名，如Sprite的全名就是flash.display::Sprite

InjectionConfig私有属性如下：

属性名	功能
m_injector : Injector	工作的注入器，如果这个属性被设置的话，被设置的注入器对这个注入配置有最高的优先级。在getResponse时，会直接调用这个注入器，而不是当做参数传入的注入器
m_result : InjectionResult	返回策略。如一个类映射，该值就是InjectionClassResult，以此类推。一个注入配置必须要有一个返回策略才算是有效的注入配置，如果该值是空，在注入器看来这个注入配置就是一个无效配置

InjectionConfig公共方法如下：

方法名	功能
InjectionConfig(request : Class, injectionName : String)	构造函数，新建一个注入配置，出事话请求的类和注入名
getResponse(injector : Injector) : Object	获得请求的结果，优先以m_injector作为注入器查找结果，如果没有m_injector,则以当参数传入的注入器查找，如果没有，就查找m_injector的父注入器中查找，最后再以当参数传入的注入器的父注入器中查找。
hasResponse(injector : Injector) : Boolean	检查是否可以返回一个请求结果。首先检查自身是否有返回策略，如果没有，就会检查父注入器中是否有相应的有效注入配置
hasOwnResponse() : Boolean	检查是否自身就可以返回结果，而不需要调用父注入器的注入配置
setResult(result : InjectionResult) : void	设置返回策略。
setInjector(injector : Injector) : void	设置该诸如配置工作的注入器环境

InjectionConfig类完整注释如下：

/*
* Copyright (c) 2009 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders
{
import flash.utils.getQualifiedClassName;
import org.swiftsuspenders.injectionresults.InjectionResult;
public class InjectionConfig
{
/*******************************************************************************************
* public properties *
*******************************************************************************************/
public var request : Class;//请求的类
public var injectionName : String;//注入名
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var m_injector : Injector;//工作的注入器，如果设置了，在getResonse时优先在该注入器上工作。如果没有，则使用传入的注入器
private var m_result : InjectionResult;//返回对象策略
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectionConfig(request : Class, injectionName : String)
{
this.request = request;
this.injectionName = injectionName;
}
/**
* InjectionConfig对象获取反馈对象方法
* @param injector - 注入容器
* */
public function getResponse(injector : Injector) : Object
{
if (m_result)//如果有m_result
{
return m_result.getResponse(m_injector || injector);//如果有m_injector，以m_injecotor返回，不然以injector返回
}
//如果没有m_result，即没有设置策略
var parentConfig : InjectionConfig =
(m_injector || injector).getAncestorMapping(request, injectionName);//从m_injector或者injector中得到有效祖先的映射
if (parentConfig)//如果有祖先映射
{
return parentConfig.getResponse(injector);//从祖先映射中获取对象并返回
}
return null;//如果啥都没有，返回null
}
/**
* 检查是否有可以返回结果
* @param injector - 注入容器
* @return 返回是否可以返回结果
* */
public function hasResponse(injector : Injector) : Boolean
{
if (m_result)//如果有m_result
{
return true;//可以
}
var parentConfig : InjectionConfig =
(m_injector || injector).getAncestorMapping(request, injectionName);//从m_injector或者injector的父注入器中查找有效注入配置
return parentConfig != null;//如果有则会调用父注入器的有效注入配置
}
/**
* 检查是否有可以仅凭自身返回结果，不需要查找父注入器
* @return 返回是否可以仅凭自身就返回结果
* */
public function hasOwnResponse() : Boolean
{
return m_result != null;//返回是否有m_result
}
/**
* 设置返回策略
* @param result - 返回的策略
* */
public function setResult(result : InjectionResult) : void
{
if (m_result != null && result != null)//如果m_result不为空且当且设置的不为空，即要替换
{
trace('Warning: Injector already has a rule for type "' +
getQualifiedClassName(request) + '", named "' + injectionName + '".\n ' +
'If you have overwritten this mapping intentionally you can use ' +
'"injector.unmap()" prior to your replacement mapping in order to ' +
'avoid seeing this message.');//抛出警告，建议先调用unmap方法解除映射，然后再进行映射
}
m_result = result;//无论如何都会设置m_result
}
/**
* 设置工作的注入器环境
* @param injector - 设置的注入器
* */
public function setInjector(injector : Injector) : void
{
m_injector = injector;//对m_injector赋值
}
}
}

复制代码

InjectionType

InjectionType枚举了注入的映射类型。但是根本就没有用到。因此不具体阐述。

InjectorError

InjectorError是注入异常。仅仅扩展了Error类，其他什么都没干。不具体阐述。

Reflector

Relector类中包含于反射相关的一些函数。但是在框架中也没有用到，因此不具体阐述。

getConstructor

getConstructor函数可以获取一个对象对应的类。其机制参见http://sswilliam.blog.163.com/blog/static/18969638320116311531950/

每一个对象都有一个constructor属性指向他的类。但是Proxy，Number, XML，和XMLList在调用constructor时会有不同的问题，解决的方案就是先获取对象的全面，然后通过getDefinitionByName来反射寻找相应的类。

破晓 · 发表于 2015-1-10 21:32:31

InjectionPoint

InjectionPoint类是所有注入点的父类，是一个抽象类。ConstructorInjectionPoint构造函数注入点，NoParamsConstructorInjectionPoint无参数的构造函数注入点，MethodInjectionPoint方法注入点，PropertyInjectionPoint属性注入点，PostConstructInjectionPoint，PostConstruct注入点都是InjectionPoint的子类，通过重写initalizeInjection方法实现不同的注入点的相关功能。同是会重写applyInjection方法风别实现相应注入点的注入。

InjectionPoint公共方法

方法名	功能
InjectionPoint(node : XML, injector : Injector)	构造函数，通过传入包含注入信息的xml节点，通过调用initializeInjection方法初始化注入点，initializeInjection是个钩子方法，通过不同的子类重写从而实现不同的注入点。
applyInjection(target : Object, injector : Injector) : Object	抽象的应用注入方法，由子类重写，从而实现不同注入点的注入
initializeInjection(node : XML) : void	初始化注入点，由子类重写，从而实现不同注入点的注入

InjectionPoint类完整注释如下：

/*
* Copyright (c) 2009 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionpoints
{
import org.swiftsuspenders.Injector;
/**
* 注入点父类，抽象类，传入xml和Injector对象，调用initializeInjection钩子方法，采用模板方法
* */
public class InjectionPoint
{
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectionPoint(node : XML, injector : Injector)
{
initializeInjection(node);
}
/**
* 抽象应用注入方发
* @param target - 注入目标
* @param injector - 注入器对象
* @return target 返回结果
* */
public function applyInjection(target : Object, injector : Injector) : Object
{
return target;//返回注入目标
}
/*******************************************************************************************
* protected methods *
*******************************************************************************************/
/**
* 抽象钩子方法，由子类实现,以一个带有注入信息的xml作为参数
* */
protected function initializeInjection(node : XML) : void
{
}
}
}

复制代码

PropertyInjectionPoint

PropertyInjectionPoint是属性注入点，被[Inject]标记公共属性和setter方法都属于属性注入点。公共属性和setter方法在通过describeType方法得到的xml中，节点的name属性的值都是property。因此把他们都归于属性注入点。

PropertyInjectionPoint私有属性如下：

以[Inject(name='haha')]public var a:A;为例

属性名	功能
_propertyName : String	注入点名称，就是a
_propertyType : String	注入点的类型，就是A
_injectionName : String;	注入名，就是haha

PropertyInjectionPoint主要方法如下：

方法名	功能
PropertyInjectionPoint(node : XML, injector : Injector = null)	构造函数，调用父类构造函数，初始化对象
applyInjection(target : Object, injector : Injector) : Object	重写的应用注入方法，针对属性注入点，直接将对象里面的注入点名称的那个属性赋值即可。所赋的值是通过injector得到的，因此如果所赋的值仍然需要依赖注入的话，会先注入那个需要的值，然后再将这个值注入进目标对象。
initializeInjection(node : XML)	初始化注入点，根据XML的信息，分别得到_propertyName, _propertyType和_injectionName的值

PropertyInjectionPoint类完整注释如下：

/*
* Copyright (c) 2009 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionpoints
{
import org.swiftsuspenders.InjectionConfig;
import org.swiftsuspenders.Injector;
import org.swiftsuspenders.InjectorError;
/**
* 属性注入点
* */
public class PropertyInjectionPoint extends InjectionPoint
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var _propertyName : String;//注入点名称
private var _propertyType : String;//注入点的类型
private var _injectionName : String;//注入名
/*******************************************************************************************
* public methods *
*******************************************************************************************/
/**
* 构造函数
* */
public function PropertyInjectionPoint(node : XML, injector : Injector = null)
{
super(node, null);//会调用initializeInjection（node）方法
}
/**
* 属性注入点应用注入函数
* @param target - 被注入的对此昂
* @param injector - injector对象，注入容器
* @return 返回被注入的对象
* */
override public function applyInjection(target : Object, injector : Injector) : Object
{
var injectionConfig : InjectionConfig = injector.getMapping(Class(
injector.getApplicationDomain().getDefinition(_propertyType)), _injectionName);//从injector中获取映射的InjectionConfig对象
var injection : Object = injectionConfig.getResponse(injector);//从InjectionConfig对象中获取实例
//
if (injection == null)//如果injection为空
{
throw(new InjectorError(
'Injector is missing a rule to handle injection into property "' +
_propertyName + '" of object "' + target +
'". Target dependency: "' + _propertyType + '", named "' + _injectionName +
'"'));//抛出异常
}
target[_propertyName] = injection;//具体注入，将target._propertyName赋值为injection
return target;//返回target实际上target已经改变
}
/*******************************************************************************************
* protected methods *
*******************************************************************************************/
/**
* 通过xml初始化注入,初始化属性注入点
* @param node - 是metadata name为 Inject的节点
* */
override protected function initializeInjection(node : XML) : void
{
/**
* _propertyType:属性类型
* _propertyName:属性名称
* _injectionName:注入名
* 如：
* [Inject(name='haha')]public var a:A;
* A就是属性类型
* a就是属性名称
* haha就是注入名，就是在mapClass后面的最后一个参数
* 改node的的值是<metadata name="Inject"/>
* 其parent就包含了整个属性的类型描述
* 如：
<variable name="property" type="org.swiftsuspenders.support.types::Clazz">
<metadata name="Inject">
<arg key="name" value="haha"/>
</metadata>
<metadata name="__go_to_definition_help">
<arg key="pos" value="1312"/>
</metadata>
</variable>
* */
_propertyType = node.parent().@type.toString();//设置注入点的类型
_propertyName = node.parent().@name.toString();//设置注入点名称
_injectionName = node.arg.attribute('value').toString();//设置注入名
}
}
}

复制代码

破晓 · 发表于 2015-1-10 21:34:08

MethodInjectionPoint

MethodInjectionPoint是方法注入点，被[Inject]标记公共方法都属于方法注入点。公共方法在通过describeType方法得到的xml中，节点的name属性的值都是method。

MethodInjectionPoint受保护属性如下：

属性名	功能
methodName : String	注入点名称，就是方法名
_parameterInjectionConfigs : Array	注入参数，与属性注入点不同，方法注入点可以有多个参数
requiredParameters : int	需要的参数数

MethodInjectionPoint主要方法如下：

方法名	功能
MethodInjectionPoint (node : XML, injector : Injector = null)	构造函数，调用父类构造函数，初始化对象
applyInjection(target : Object, injector : Injector) : Object	重写的应用注入方法，针对方法注入点，首先先回获取函数的参数值，然后得到函数的应用，最后调用apply方法执行函数从而完成注入。
initializeInjection(node : XML)	初始化注入点，根据XML的信息，分别得到得到methodName信息，然后会调用gatherParameters方法获得该函数的参数
gatherParameters( methodNode : XML, nameArgs : XMLList)	通过解析XML的信息获得注入函数所需的参数名称，包括是否该参数包含注入名
gatherParameterValues( target : Object, injector : Injector)	获取函数参数的值。通过注入器获取相应的对象，这样如果参数的值任然需要依赖注入，就会先对这些值进行注入，存储到_parameterInjectionConfigs以供注入

MethodInjectionPoint包外类ParameterInjectionConfig：这个类包含了对方法注入的每个参数的注入信息，包括参数名和注入名，以方便注入使用。

MethodInjectionPoint类完整注释如下：

/*
* Copyright (c) 2009 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionpoints
{
import flash.utils.getQualifiedClassName;
import org.swiftsuspenders.InjectionConfig;
import org.swiftsuspenders.Injector;
import org.swiftsuspenders.InjectorError;
/**
* 方法注入点
* */
public class MethodInjectionPoint extends InjectionPoint
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
/**
* 方法名
* */
protected var methodName : String;
/**
*
* */
protected var _parameterInjectionConfigs : Array;//该函数注入点参数注入配置
protected var requiredParameters : int = 0;//如要的参数数
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function MethodInjectionPoint(node : XML, injector : Injector = null)
{
super(node, injector);
}
/**
* 方法注入点应用注入函数
* @param target - 被注入的对象
* @param injector - 注入器
* @return 返回被注入的对象
* */
override public function applyInjection(target : Object, injector : Injector) : Object
{
var parameters : Array = gatherParameterValues(target, injector);//获取参数的值
var method : Function = target[methodName];//获取需要注入的函数
method.apply(target, parameters);//按照参数来调用函数
return target;//返回目标，此时已经调用输入函数
}
/*******************************************************************************************
* protected methods *
*******************************************************************************************/
/**
* 通过xml初始化注入,初始化方法注入点
* @param node - 是metadata name为 Inject的节点
* */
override protected function initializeInjection(node : XML) : void
{
var nameArgs : XMLList = node.arg.(@key == 'name');//获取参数名
var methodNode : XML = node.parent();//获取父节点
methodName = methodNode.@name.toString();//获取注入方法方法名
gatherParameters(methodNode, nameArgs);//获取参数
}
/**
* 获取参数，实际是向_parameterInjectionConfigs赋值，包涵了该函数注入点的参数名
* @param node
* 如一个方法注入的xml描述如下
* <method name="setDependencies" declaredBy="org.swiftsuspenders.support.injectees::TwoParametersMethodInjectee" returnType="void">
<parameter index="1" type="org.swiftsuspenders.support.types::Clazz" optional="false"/>
<parameter index="2" type="org.swiftsuspenders.support.types::Interface" optional="false"/>
<metadata name="Inject">
<arg key="name" value="haha"/>
</metadata>
<metadata name="__go_to_definition_help">
<arg key="pos" value="1467"/>
</metadata>
</method>
* 有两个参数，切optional都是false
* 一个类型是clazz，还有一个是Intrface,
* Inject的参数中name参数就是每个注入参数分别的注入名
* 如
* [Inject(name="haha",name="haha2")]
public function setDependencies(dependency:Clazz, dependency2:Interface):void
{
m_dependency = dependency;
m_dependency2 = dependency2;
}
* 则此时dependency的注入名为haha，dependency2的注入名为haha2
* injector的映射此时就要有注入名的隐射，如：
var inj:Injector = new Injector();
inj.mapSingleton(Clazz,"haha");
inj.mapClass(Interface,Clazz2,"haha2");
inj.injectInto(injectee);
* */
protected function gatherParameters(methodNode : XML, nameArgs : XMLList) : void
{
_parameterInjectionConfigs = [];//清空参数
var i : int = 0;
for each (var parameter : XML in methodNode.parameter)//遍历parameter节点
{
var injectionName : String = '';//初始化注入名
if (nameArgs[i])//如果nameArgs第i位有
{
injectionName = nameArgs[i].@value.toString();//注入名就是nameArgs[i]的value属性
}
var parameterTypeName : String = parameter.@type.toString();//参数类型名是param的type属性
if (parameterTypeName == '*')//如果类型是*
{
if (parameter.@optional.toString() == 'false')//如果optional属性时false
{
//TODO: Find a way to trace name of affected class here
throw new InjectorError('Error in method definition of injectee. ' +
'Required parameters can\'t have type "*".')//抛出异常，取药的参数不能是*类型
}
else//如果optional是true
{
parameterTypeName = null;//类型的名称为null
}
}
_parameterInjectionConfigs.push(
new ParameterInjectionConfig(parameterTypeName, injectionName));//向参数注入配置中添加一个配置对象
if (parameter.@optional.toString() == 'false')//如果optional属性时false
{
requiredParameters++;//需要的参数+1
}
i++;
}
}
/**
* 获取参数的值
* @param target - 注入目标
* @param injector - 注入器
*
* */
protected function gatherParameterValues(target : Object, injector : Injector) : Array
{
var parameters : Array = [];//申明返回值
var length : int = _parameterInjectionConfigs.length;//长度，就是参数诸如配置的长度
for (var i : int = 0; i < length; i++)//遍历_parameterInjectionConfigs
{
var parameterConfig : ParameterInjectionConfig = _parameterInjectionConfigs[i];//获取第I个参数注入配置
var config : InjectionConfig = injector.getMapping(Class(
injector.getApplicationDomain().getDefinition(parameterConfig.typeName)),
parameterConfig.injectionName);//从injector获得相应的注入配置，通过类和注入名来获取
var injection : Object = config.getResponse(injector);//获得对象/
//个人觉得直接用injector.getInstance()就可以了
if (injection == null)//如果是空
{
if (i >= requiredParameters)//如果已经超出了需要的参数个数，即有可选参数
{
break;//直接跳出
}//否则抛出异常
throw(new InjectorError(
'Injector is missing a rule to handle injection into target ' + target +
'. Target dependency: ' + getQualifiedClassName(config.request) +
', method: ' + methodName + ', parameter: ' + (i + 1)
));
}
parameters[i] = injection;//将值加入返回的参数列表
}
return parameters;//返回参数的值
}
}
}
/**
* 参数注入配置，包涵注入参数的类型和注入名，这样就可以从injector中getInstance(Class,name)获得需要注入的对象
* */
final class ParameterInjectionConfig
{
public var typeName : String;//类型名
public var injectionName : String;//注入名
public final function ParameterInjectionConfig(typeName : String, injectionName : String)
{
this.typeName = typeName;
this.injectionName = injectionName;
}
}

复制代码

破晓 · 发表于 2015-1-10 21:35:48

ConstructorInjectionPoint

ConstructornInjectionPoint是构造函数注入点，在类前添加[Inject]元数据标签就会申明构造函数注入点。继承自MethodInjectionPoint。

ConstructornInjectionPoint主要方法如下：

方法名	功能
ConstructorInjectionPoint(node : XML, clazz : Class, injector : Injector = null)	构造函数，注意Flash player在一个类至少被实例化一次之前不会给出type信息。会调用createDummyInstance方法假装实例一下这个类，然后将获得的类的XML描述进行更新。
applyInjection(target : Object, injector : Injector) : Object	应用注入，会将注入的参数手动的new到构造函数里，注意只能有10个参数，由于构造函数无法apply，所以只能手动的来new，具体见注释
initializeInjection(node : XML) : void	初始化注入点，会调用父类的gatherParamenters方法来寻找到所有的要注入的参数名
createDummyInstance( constructorNode : XML, clazz : Class)	尝试实例化一个类，并且更新类的XML描述信息，以解决不能得到type信息的bug

ConstructornInjectionPoint类完整注释如下：

/*
* Copyright (c) 2009 the original author or authors
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionpoints
{
import flash.utils.describeType;
import org.swiftsuspenders.Injector;
/**
* 构造函数注入点，扩展自MethodInjectionPoint
* */
public class ConstructorInjectionPoint extends MethodInjectionPoint
{
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function ConstructorInjectionPoint(
node : XML, clazz : Class, injector : Injector = null)
{
/*
In many cases, the flash player doesn't give us type information for constructors until
the class has been instantiated at least once. Therefore, we do just that if we don't get
type information for at least one parameter.
*/
/**
* 在许多情况下，Flash player在一个类至少被实例化一次之前不会给出type信息。因此我们先假装实例一下从而来获得类型信息
* */
if (node.parameter.(@type == '*').length() == node.parameter.@type.length())//如果所有的参数类型都是*
{
createDummyInstance(node, clazz);//调用createDummyInstance函数，以解决FP的bug
}
super(node, injector);
}
override public function applyInjection(target : Object, injector : Injector) : Object
{
var ctor : Class = Class(target);//target是一个Class
var p : Array = gatherParameterValues(target, injector);//获得构造函数的参数的值，调用父类方法
//the only way to implement ctor injections, really!
/**
* 唯一实现构造函数注入的方法，所以只能少于10个参数的构造函数
* */
switch (p.length)
{
case 0 : return (new ctor());
case 1 : return (new ctor(p[0]));
case 2 : return (new ctor(p[0], p[1]));
case 3 : return (new ctor(p[0], p[1], p[2]));
case 4 : return (new ctor(p[0], p[1], p[2], p[3]));
case 5 : return (new ctor(p[0], p[1], p[2], p[3], p[4]));
case 6 : return (new ctor(p[0], p[1], p[2], p[3], p[4], p[5]));
case 7 : return (new ctor(p[0], p[1], p[2], p[3], p[4], p[5], p[6]));
case 8 : return (new ctor(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]));
case 9 : return (new ctor(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]));
case 10 : return (new ctor(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9]));
}
return null;
}
/*******************************************************************************************
* protected methods *
*******************************************************************************************/
override protected function initializeInjection(node : XML) : void
{
var nameArgs : XMLList = node.parent().metadata.(@name == 'Inject').arg.(@key == 'name');//获得包含参数的子节点
methodName = 'constructor';//将方法名赋值为constructor,其实不赋值也没关系，因为构造函数输入用不到这个熟悉
gatherParameters(node, nameArgs);//获取要注入的参数名
}
/*******************************************************************************************
* private methods *
*******************************************************************************************/
/**
* 为了防止无法获得构造函数的type信息，从而
* */
private function createDummyInstance(constructorNode : XML, clazz : Class) : void
{
try//尝试new一下这个类，如果不行则抛出异常
{
switch (constructorNode.children().length())
{
case 0 : (new clazz()); break;
case 1 : (new clazz(null)); break;
case 2 : (new clazz(null, null)); break;
case 3 : (new clazz(null, null, null)); break;
case 4 : (new clazz(null, null, null, null)); break;
case 5 : (new clazz(null, null, null, null, null)); break;
case 6 : (new clazz(null, null, null, null, null, null)); break;
case 7 : (new clazz(null, null, null, null, null, null, null)); break;
case 8 : (new clazz(null, null, null, null, null, null, null, null)); break;
case 9 : (new clazz(null, null, null, null, null, null, null, null, null)); break;
case 10 : (new clazz(null, null, null, null, null, null, null, null, null, null)); break;
}
}
catch (error : Error)
{
trace('Exception caught while trying to create dummy instance for constructor ' +
'injection. It\'s almost certainly ok to ignore this exception, but you ' +
'might want to restructure your constructor to prevent errors from ' +
'happening. See the SwiftSuspenders documentation for more details. ' +
'The caught exception was:\n' + error);
}//在new完之后，不论是否new成功，类的xml描述就可以获得了
constructorNode.setChildren(describeType(clazz).factory.constructor[0].children());//重新设置XML信息
}
}
}

复制代码

NoParamsConstructorInjectionPoint

NoParamsConstructornInjectionPoint是无参构造函数注入点，解决所有没有构造函数注入的类的实例化问题

NoParamsConstructornInjectionPoint主要方法如下：

属性名	功能
NoParamConstructorInjectionPoint	构造函数，直接默认即可，因为就是为了实现new一个目标类的问题
applyInjection(target : Object, injector : Injector) : Object	直接new出目标类的对象并返回即可。

很简单，就不给出注释了，直接看代码即可。

PostConstructInjectionPoint

PostConstructInjectionPoint表示了那些完成注入后需要执行的方法，也将他们抽象为注入点进行处理，通过[PostConstruct]标记出的方法就会被SwiftSuspenders添加为PostConstrucInjectionPoint。

PostConstructInjectionPoint主要属性如下：

属性名	功能
methodName:String	需要调用的方法名
orderValue:int	调用的顺序，可能一个类会有多个方法被标记为PostConstruct。通过该值决定调用方法的顺序

PostConstructInjectionPoint主要方法如下：

方法名	功能
PostConstructInjectionPoint(node:XML, injector : Injector = null)	构造函数，直接调用父类的构造函数
applyInjection(target : Object, injector : Injector) : Object	直接调用目标的该方法即可，注意申明为PostConstruct的方法都是无参数的方法
initializeInjection(node : XML)	初始化该注入点，通过获得order参数的值得到调用的顺序
get order():int	获得该PostConstruct的被调用顺序的值

PostConstructInjectionPoint主要方法如下：

/*
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionpoints
{
import org.swiftsuspenders.Injector;
/**
* 实际不是注入点，通过配置PostConstructInjectionPoint，可以再完成注入后执行相应的函数，order代表执行顺序顺序
* 如
[PostConstruct(order="2")]
public function post2():void{
trace("post2");
}
[PostConstruct(order="1")]
public function post1():void{
trace("post1");
}
* 当类中有这两个函数时
* 在该类完成注入时
* 就会先执行post1,再执行post2
* order决定了执行顺序
* */
public class PostConstructInjectionPoint extends InjectionPoint
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
protected var methodName : String;//方法名
protected var orderValue:int;//顺序
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function PostConstructInjectionPoint(node:XML, injector : Injector = null)
{
super(node, injector);
}
public function get order():int
{
return orderValue;
}
override public function applyInjection(target : Object, injector : Injector) : Object
{
target[methodName]();//调用target的methodName方法
return target;
}
/*******************************************************************************************
* protected methods *
*******************************************************************************************/
override protected function initializeInjection(node : XML) : void
{
var orderArg : XMLList = node.arg.(@key == 'order');//获取key是order节点
var methodNode : XML = node.parent();//获取PostConstruct XML节点
orderValue = int(orderArg.@value);//orderArg的value属性赋值给orderValue
methodName = methodNode.@name.toString();//节点的name属性赋值给method，方法名
}
}
}

复制代码

破晓 · 发表于 2015-1-10 21:40:12

InjectionResult

InjectionResult是返回策略的父类，有一个抽象的getResponse方法，各种返回结果的子类可以通过重写该方法实现相应的返回策略

InjectionResult主要方法如下：

方法名	功能
InjectionResult()	构造函数
getResponse(injector : Injector) : Object	抽象方法，由子类重写以实现相应的返回策略

类很简单，不给出注释

InjectClassResult

InjectClassResult会返回一个类的实例。每次调用都会将该类重新实例一次，然后返回

InjectClassResult主要属性如下：

属性名	功能
m_responseType : Class	需要返回的类

InjectClassResult主要方法如下：

方法名	功能
InjectClassResult(responseType : Class)	构造函数，传实例化入需要的类
getResponse(injector : Injector) : Object	通过调用传入的注入器的initantiate方法从注入器获得该类的实例，如果该类仍然需要注入，注入器会完成依赖注入。

InjectClassResult完整注释如下：

<font color="#000000">/*
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionresults
{
import org.swiftsuspenders.Injector;
public class InjectClassResult extends InjectionResult
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var m_responseType : Class;//需要实例化的类
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectClassResult(responseType : Class)
{
m_responseType = responseType;//赋值
}
override public function getResponse(injector : Injector) : Object
{
return injector.instantiate(m_responseType);//通过注入器进行实例化，这样保证得到的实例是已经经过依赖注入的
}
}
}</font>

复制代码

InjectSingletonResult

InjectSingletonResult会返回一个类的单例对象。所有的这个对象的使用者共享这个对象。

InjectSingletonResult主要属性如下：

属性名	功能
m_responseType : Class	需要返回的类
m_response:Object	单例对象的引用

InjectSingletonResult主要方法如下：

方法名	功能
InjectSingletonResult(responseType : Class)	构造函数，传入需要实例化的类
getResponse(injector : Injector) : Object	返回类的单例对象
createResponse(injector : Injector) : Object	创建类的对象，并将其赋值给m_response，这样在调用getResponse时，如果m_response为空，就通过注入器获得该对象的实例，然后返回，如果m_response不为空，则直接返回m_response，这样实现单例的效果

InjectSingletonResult完整注释如下：

<font color="#000000">/*
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionresults
{
import org.swiftsuspenders.Injector;
public class InjectSingletonResult extends InjectionResult
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var m_responseType : Class;//需要实例化的类
private var m_response : Object;//单例的引用
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectSingletonResult(responseType : Class)
{
m_responseType = responseType;//赋值
}
override public function getResponse(injector : Injector) : Object
{
return m_response ||= createResponse(injector);//通过此种方式实现单例模式，第一次会调用instantiate方法生成一个实例，
//并对m_response进行赋值，以后值接返回m_response
}
/*******************************************************************************************
* private methods *
*******************************************************************************************/
private function createResponse(injector : Injector) : Object
{
return injector.instantiate(m_responseType);//创建一个实例，通过调用注入器获得需要返回的对象，这样保证返回的对象是已经完成注入过的对象。
}
}
}</font>

复制代码

InjectValueResult

InjectValueResult会返回预先设定好的对象。

InjectValueResult主要属性如下：

属性名	功能
m_value : Object	需要返回的值的引用

InjectValueResult主要方法如下：

方法名	功能
InjectValueResult(value : Object)	构造函数，传入需要返回的对象
getResponse(injector : Injector) : Object	返回类需要返回的对象

InjectValueResult完整注释如下：

/*
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionresults
{
import org.swiftsuspenders.Injector;
public class InjectValueResult extends InjectionResult
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var m_value : Object;//需要返回的对象
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectValueResult(value : Object)
{
m_value = value;//设置m_value
}
override public function getResponse(injector : Injector) : Object
{
return m_value;//返回m_value
}
}
}

复制代码

InjectOtherRuleResult

InjectOtherRuleResult会调用另外的注入配置的返回策略，从而达到复用的效果。同时也可以通过在InjectConfig中设置自定义的返回策略而扩展框架。不过个人感觉这个功能比较鸡肋。没有太大的用处。

InjectOtherRuleResult主要属性如下：

属性名	功能
m_rule : InjectionConfig	需要复用的注入配置对象

InjectOtherRuleResult主要方法如下：

方法名	功能
InjectOtherRuleResult(rule : InjectionConfig)	构造函数，传入需要返回的注入配置对象
getResponse(injector : Injector) : Object	调用注入配置的返回策略，达到复用的目的

InjectValueResult完整注释如下：

/*
*
* Permission is hereby granted to use, modify, and distribute this file
* in accordance with the terms of the license agreement accompanying it.
*/
package org.swiftsuspenders.injectionresults
{
import org.swiftsuspenders.InjectionConfig;
import org.swiftsuspenders.Injector;
//其他规则，复用其他InjectionConfig的返回策略，
public class InjectOtherRuleResult extends InjectionResult
{
/*******************************************************************************************
* private properties *
*******************************************************************************************/
private var m_rule : InjectionConfig;//其他的注入配置
/*******************************************************************************************
* public methods *
*******************************************************************************************/
public function InjectOtherRuleResult(rule : InjectionConfig)
{
m_rule = rule;//设置注入配置
}
override public function getResponse(injector : Injector) : Object
{
return m_rule.getResponse(injector);//调用其他的注入配置的返回策略
}
}
}

复制代码

总结

至此这篇SwiftSuspenders1.6 浅出深入就写完了。框架这个东西有利有弊，特别是对新手而言，使用框架，可以让新手很容易的加入到团队的开发中，但是如果对框架没有很好的理解，很可能会偏离框架原有的初衷。要想很好的理解框架，阅读框架的代码无疑是最直接有效的方法了，这也是我写这篇文章的目的所在。同时阅读代码，可以学习到很多编程上面的技巧和思想，对自身的提高也是很有帮助的，比如swiftSuspenders中，很多有关元数据，反射的AS的特性，在一般的开发中是很少能接触到的。我会把我注释过的源代码上传，以方便大家查阅。

由于个人能力有限，文章中出现一些错误在所难免，欢迎大家批评指正。希望能与大家进行更多的交流。

帐号		自动登录	找回密码
密码			立即注册

[ActionScript] SwiftSuspenders 1.6 浅出深入深入

本帖子中包含更多资源

开源英雄

守望者

站长推荐 /4

[ActionScript] SwiftSuspenders 1.6 浅出深入 深入

本帖子中包含更多资源

开源英雄

守望者

站长推荐 /4

[ActionScript] SwiftSuspenders 1.6 浅出深入深入