我记录开源系统1.6源码解析(二)之IOC容器浅析

这篇为了进一步加深对我记录IOC管理容器的运行流程，我们继续分析ObjectContext这个类。主要是对InitInJect这个方

法继续分析。

private static void InitInject( ObjectContext ctx ) {
loadAssemblyAndTypes( ctx );
resolveAndInject( ctx );
addNamedObjects( ctx );
}

ObjectContext类位于wojilu项目的DI文件夹中，如图：





可以看到DI文件夹里包含MapItem和ObjectContext两个类。说明这两个类跟DI紧密关联。

第一行调用loadAssemblyAndTypes方法:

private static void loadAssemblyAndTypes( ObjectContext ctx ) {

String appSettings = cfgHelper.GetAppSettings( "InjectAssembly" );//读取web.config里的key为InjectAssembly的配置项
if (strUtil.IsNullOrEmpty( appSettings )) return;

String[] strArray = appSettings.Split( new char[] { ',' } );
foreach (String asmStr in strArray) {//遍历所有以","分割的程序集

if (strUtil.IsNullOrEmpty( asmStr )) continue;
String asmName = asmStr.Trim();
Assembly assembly = loadAssemblyPrivate(asmName, ctx);//加载web.config中的InjectAssembly，并加入ObjectContext
findTypesPrivate( assembly, asmName, ctx );
}
}

我们看看loadAssemblyPrivate这个方法:

/// <summary>
/// 根据程序集名称加载web.config中的InjectAssembly，并加入ObjectContext
/// </summary>
/// <param name="asmName">程序集名称</param>
/// <param name="ctx">容器实例</param>
/// <returns>返回程序集</returns>
private static Assembly loadAssemblyPrivate( String asmName, ObjectContext ctx ) {
Assembly assembly = Assembly.Load( asmName );//根据程序集名称加载程序集
ctx.AssemblyList.Add( asmName, assembly );//加入ObjectContext的AssemblyList(所有纳入容器管理的程序集)
return assembly;//返回程序集
}

接下来findTypesPrivate方法:

private static void findTypesPrivate( Assembly assembly, String asmName, ObjectContext ctx ) {
Type[] types = assembly.GetTypes();//返回程序集里定义的类型
ctx.AssemblyTypes.Add(asmName, types);//这里加入ObjectContext的AssemblyTypes属性,所有程序集名称，所有类型

foreach (Type type in types) {//遍历程序集下的所有类型
ctx.TypeList.Add(type.FullName, type);//这里加入InjectAssembly下的TypeList所有类型，所有纳入容器管理的类型
}
}

loadAssemblyAndTypes方法还是没什么很多的内容的,我们看看第二行的resolveAndInject( ctx ):

private static void resolveAndInject( ObjectContext ctx ) {
List<MapItem> maps = cdb.findAll<MapItem>();//查询所有依赖注入里的配置项
if (maps.Count <= 0) return;

Dictionary<String, MapItem> resolvedMap = new Dictionary<String, MapItem>();

logger.Info( "resolve item begin..." );//记录日志
resolveMapItem( maps, resolvedMap, ctx );//处理所有MapItem

logger.Info( "inject Object begin..." );
injectObjects( maps, resolvedMap );//resolvedMap，处理过的MapItem:wojilu.Web.Context.ContextInit

ctx.ResolvedMap = resolvedMap;
}

List<MapItem> maps = cdb.findAll<MapItem>();展开后涉及到比较多的代码,我们来把部分代码展开:

/// <summary>
/// 查询类型 T 的所有数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>返回所有数据的列表</returns>
public static List<T> findAll<T>() where T : CacheObject {
IList list = MemoryDB.FindAll( typeof( T ) );//如wojilu.DI.MapItem
return db.getResults<T>( list );
}

这个方法在cdb类里：

/// <summary>
/// 从内存数据库中查询数据
/// </summary>
/// <remarks>
/// 数据持久化在 /framework/data/ 目录下，以json格式存储。加载之后常驻内存。
/// 特点：直接从内存中检索，速度相当于 Hashtable。插入和更新较慢(相对而言)，因为插入和更新会在内存中重建索引。
/// </remarks>
public class cdb

cdb.findAll<T>()方法又会调用MemoryDB.FindAll(typeof(T)):

internal static IList FindAll( Type t ) {
return new ArrayList( GetObjectsByName( t ) );
}

GetObjectsByName(Type t)如下:

/// <summary>
/// 根据类型t得到以该类型t命名的配置文件中的所有类型
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
private static IList GetObjectsByName( Type t ) {

if (isCheckFileDB( t )) {//是否应该检查配置文件

lock (chkLock) {

if (isCheckFileDB( t )) {

loadDataFromFile( t );//从配置文件加载类型t
_hasCheckedFileDB[t] = true;

}

}

}
return (objectList[t.FullName] as IList);
}

loadDataFromFile(Type t )方法如下:

/// <summary>
/// 从配置文件中加载所有类型
/// </summary>
/// <param name="t"></param>
private static void loadDataFromFile( Type t ) {
if (wojilu.IO.File.Exists( getCachePath( t ) )) {//检查以类型t命名的配置文件是否存在
IList list = getListWithIndex( wojilu.IO.File.Read( getCachePath( t ) ), t );
objectList[t.FullName] = list;
}
else {
objectList[t.FullName] = new ArrayList();
}
}

最主要是getListWithIndex( String jsonString, Type t )方法:

private static IList getListWithIndex( String jsonString, Type t ) {

IList list = new ArrayList();

if (strUtil.IsNullOrEmpty( jsonString )) return list;

List<object> lists = JsonParser.Parse( jsonString ) as List<object>;//解析json格式的数组,返回Dictionary类型的数组，包含Name,Type

foreach (Dictionary<String, object> map in lists) {//遍历

CacheObject obj = JSON.setValueToObject( t, map ) as CacheObject;//把json数组里的Type转换为t对象里的属性
int index = list.Add( obj );
addIdIndex( t.FullName, obj.Id, index );
makeIndexByInsert( obj );
}

return list;
}

 

至于resolveMapItem和injectObjects

private static void resolveMapItem( List<MapItem> maps, Dictionary<String, MapItem> resolvedMap, ObjectContext ctx )

private static void     injectObjects( List<MapItem> mapItems, Dictionary<String, MapItem> resolvedMap )

 

两个方法也是跟注入对象相关。我们最后来看下addNamedObjects方法:

private static void addNamedObjects( ObjectContext ctx ) {
Dictionary<String, MapItem> resolvedMap = ctx.ResolvedMap;
Hashtable namedObjects = new Hashtable();
foreach (KeyValuePair<String, MapItem> entry in resolvedMap) {
MapItem item = entry.Value;
namedObjects.Add( item.Name, item.TargetObject );
}
ctx.ObjectsByName = namedObjects;
}

这个很简单，把处理过的MapItem附给根据名称罗列的对象表(HashTable)。

总结：今后还得继续对wojilu的DI容器代码分析深入研究。