cyf
424 lines
15 KiB
C#
424 lines
15 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using Zhaizj.Framework.Reflection;
|
|
using Zhaizj.Framework.Web.Mvc;
|
|
using Zhaizj.Framework.Web.Mvc.Interface;
|
|
|
|
namespace Zhaizj.Framework.DI {
|
|
|
|
/// <summary>
|
|
/// IOC 管理容器
|
|
/// </summary>
|
|
public class ObjectContext {
|
|
|
|
private static readonly ILog logger = LogManager.GetLogger( typeof( ObjectContext ) );
|
|
|
|
private static Object syncRoot = new object();
|
|
private static volatile ObjectContext _instance;
|
|
|
|
private ObjectContext() {
|
|
}
|
|
|
|
/// <summary>
|
|
/// 容器的实例(单例)
|
|
/// </summary>
|
|
public static ObjectContext Instance {
|
|
get {
|
|
if (_instance == null) {
|
|
lock (syncRoot) {
|
|
if (_instance == null) {
|
|
ObjectContext ctx = new ObjectContext();
|
|
InitInject( ctx );
|
|
_instance = ctx;
|
|
}
|
|
}
|
|
}
|
|
return _instance;
|
|
}
|
|
}
|
|
|
|
private static void InitInject( ObjectContext ctx ) {
|
|
loadAssemblyAndTypes( ctx );
|
|
resolveAndInject( ctx );
|
|
addNamedObjects( ctx );
|
|
}
|
|
|
|
private Dictionary<String, Assembly> _assemblyList = new Dictionary<String, Assembly>();
|
|
private Dictionary<String, Type[]> _assemblyTypes = new Dictionary<String, Type[]>();
|
|
private Dictionary<String, Type> _typeList = new Dictionary<String, Type>();
|
|
|
|
|
|
private Dictionary<String, MapItem> _resolvedMap = new Dictionary<String, MapItem>();
|
|
|
|
private Hashtable _objectsContainerByName = new Hashtable();
|
|
private Hashtable _objectsContainerByType = new Hashtable();
|
|
|
|
private Dictionary<String, IDto> _dtoList = new Dictionary<string, IDto>();
|
|
|
|
/// <summary>
|
|
/// 所有纳入容器管理的程序集
|
|
/// </summary>
|
|
public Dictionary<String, Assembly> AssemblyList {
|
|
get { return _assemblyList; }
|
|
set { _assemblyList = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 所有程序集的 Dictionary
|
|
/// </summary>
|
|
public Dictionary<String, Type[]> AssemblyTypes {
|
|
get { return _assemblyTypes; }
|
|
set { _assemblyTypes = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 已经解析过的类型
|
|
/// </summary>
|
|
public Dictionary<String, MapItem> ResolvedMap {
|
|
get { return _resolvedMap; }
|
|
set { _resolvedMap = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 所有纳入容器管理的类型
|
|
/// </summary>
|
|
public Dictionary<String, Type> TypeList {
|
|
get { return _typeList; }
|
|
set { _typeList = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据名称罗列的对象表
|
|
/// </summary>
|
|
public Hashtable ObjectsByName {
|
|
get { return _objectsContainerByName; }
|
|
set { _objectsContainerByName = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据类型罗列的对象表
|
|
/// </summary>
|
|
public Hashtable ObjectsByType {
|
|
get { return _objectsContainerByType; }
|
|
set { _objectsContainerByType = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取所有的dto(工厂)，用于创建dto对象
|
|
/// </summary>
|
|
public Dictionary<String, IDto> DtoList {
|
|
get { return _dtoList; }
|
|
set { _dtoList = value; }
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// 根据依赖注入的配置文件中的 name 获取对象
|
|
/// </summary>
|
|
/// <param name="objectName"></param>
|
|
/// <returns></returns>
|
|
public static Object GetByName( String objectName ) {
|
|
|
|
if (Instance.ResolvedMap.ContainsKey( objectName ) == false) return null;
|
|
|
|
MapItem item = Instance.ResolvedMap[objectName];
|
|
if (item == null) return null;
|
|
|
|
if (item.Singleton)
|
|
return Instance.ObjectsByName[objectName];
|
|
else
|
|
return createInstanceAndInject( item );
|
|
}
|
|
|
|
/// <summary>
|
|
/// 从缓存中取对象(有注入的就注入，没有注入的直接生成)，结果是单例
|
|
/// </summary>
|
|
/// <param name="typeFullName"></param>
|
|
/// <returns></returns>
|
|
public static Object GetByType( String typeFullName ) {
|
|
if (Instance.TypeList.ContainsKey( typeFullName ) == false) return null;
|
|
Type t = Instance.TypeList[typeFullName];
|
|
return GetByType( t );
|
|
}
|
|
|
|
/// <summary>
|
|
/// 从缓存中取对象(有注入的就注入，没有注入的直接生成)，结果是单例
|
|
/// </summary>
|
|
/// <param name="t"></param>
|
|
/// <returns></returns>
|
|
public static Object GetByType( Type t ) {
|
|
|
|
if (t == null) return null;
|
|
|
|
Object result = Instance.ObjectsByType[t.FullName];
|
|
|
|
if (result == null) {
|
|
|
|
MapItem mapItem = getMapItemByType( t );
|
|
if (mapItem != null) {
|
|
result = createInstanceAndInject( mapItem );
|
|
}
|
|
else {
|
|
result = rft.GetInstance( t );
|
|
}
|
|
|
|
Instance.ObjectsByType[t.FullName] = result;
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据type，不从缓存(pool)中取，而是全新创建实例(有注入的就注入，没有注入的直接生成)，肯定不是单例
|
|
/// </summary>
|
|
/// <param name="t"></param>
|
|
/// <returns></returns>
|
|
public static Object CreateObject( Type t ) {
|
|
if (t == null) return null;
|
|
|
|
MapItem mapItem = getMapItemByType( t );
|
|
if (mapItem == null)
|
|
return rft.GetInstance( t );
|
|
else
|
|
return createInstanceAndInject( mapItem );
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据type，不从缓存(pool)中取，而是全新创建实例(有注入的就注入，没有注入的直接生成)，肯定不是单例
|
|
/// </summary>
|
|
/// <param name="typeFullName"></param>
|
|
/// <returns></returns>
|
|
public static Object CreateObject( String typeFullName ) {
|
|
if (Instance.TypeList.ContainsKey( typeFullName ) == false) return null;
|
|
Type t = Instance.TypeList[typeFullName];
|
|
return CreateObject( t );
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 根据type，不从缓存(pool)中取，而是全新创建实例(有注入的就注入，没有注入的直接生成)，肯定不是单例
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <returns></returns>
|
|
public static T Create<T>() {
|
|
return (T)CreateObject( typeof( T ) );
|
|
}
|
|
|
|
private static MapItem getMapItemByType( Type t ) {
|
|
|
|
Dictionary<String, MapItem> resolvedMap = Instance.ResolvedMap;
|
|
foreach (KeyValuePair<String, MapItem> entry in resolvedMap) {
|
|
MapItem item = entry.Value;
|
|
if (t.FullName.Equals( item.Type )) return item;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Object createInstanceAndInject( MapItem item ) {
|
|
Object currentObject = rft.GetInstance( item.TargetObject.GetType() );
|
|
Dictionary<String, object> maps = item.Map;
|
|
if (maps.Count > 0) {
|
|
foreach (KeyValuePair<String, object> entry in maps) {
|
|
Object propertyValue = GetByName( entry.Value.ToString() );
|
|
if (propertyValue != null) {
|
|
ReflectionUtil.SetPropertyValue( currentObject, entry.Key, propertyValue );
|
|
}
|
|
}
|
|
}
|
|
return currentObject;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
|
|
|
|
private static void loadAssemblyAndTypes( ObjectContext ctx ) {
|
|
|
|
String appSettings = cfgHelper.GetAppSettings( "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 );
|
|
findTypesPrivate( assembly, asmName, ctx );
|
|
}
|
|
}
|
|
|
|
private static Assembly loadAssemblyPrivate( String asmName, ObjectContext ctx ) {
|
|
Assembly assembly = Assembly.Load( asmName );
|
|
ctx.AssemblyList.Add( asmName, assembly );
|
|
return assembly;
|
|
}
|
|
|
|
private static void findTypesPrivate( Assembly assembly, String asmName, ObjectContext ctx ) {
|
|
Type[] types = assembly.GetTypes();
|
|
ctx.AssemblyTypes.Add( asmName, types );
|
|
|
|
foreach (Type type in types) {
|
|
ctx.TypeList.Add( type.FullName, type );
|
|
|
|
if (rft.IsInterface( type, typeof( IDto ) )) {
|
|
ctx.DtoList.Add( strUtil.TrimEnd( type.FullName, "Dto" ), (IDto)rft.GetInstance( type ) );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 加载程序集并返回此程序集，如果容器中已存在，则直接从容器中获取
|
|
/// </summary>
|
|
/// <param name="asmName"></param>
|
|
/// <returns></returns>
|
|
public static Assembly LoadAssembly( String asmName ) {
|
|
Assembly assembly;// = Instance.AssemblyList[asmName];
|
|
Instance.AssemblyList.TryGetValue( asmName, out assembly );
|
|
if (assembly == null) {
|
|
assembly = Assembly.Load( asmName );
|
|
Instance.AssemblyList.Add( asmName, assembly );
|
|
}
|
|
return assembly;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 加载某程序集里的所有类型，如果容器中已存在，则直接从容器中获取
|
|
/// </summary>
|
|
/// <param name="asmName"></param>
|
|
/// <returns></returns>
|
|
public static Type[] FindTypes( String asmName ) {
|
|
Type[] types;// = Instance.AssemblyTypes[asmName];
|
|
Instance.AssemblyTypes.TryGetValue( asmName, out types );
|
|
if (types == null) {
|
|
types = LoadAssembly( asmName ).GetTypes();
|
|
Instance.AssemblyTypes.Add( asmName, types );
|
|
foreach (Type type in types) {
|
|
Instance.TypeList.Add( type.FullName, type );
|
|
}
|
|
}
|
|
return types;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
|
|
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 );
|
|
|
|
logger.Info( "inject Object begin..." );
|
|
injectObjects( maps, resolvedMap );
|
|
|
|
ctx.ResolvedMap = resolvedMap;
|
|
}
|
|
|
|
private static void resolveMapItem( List<MapItem> maps, Dictionary<String, MapItem> resolvedMap, ObjectContext ctx ) {
|
|
foreach (MapItem oneMap in maps) {
|
|
Type type;// = ctx.TypeList[oneMap.Type];
|
|
ctx.TypeList.TryGetValue( oneMap.Type, out type );
|
|
if (type == null) continue;
|
|
logger.Info( "resolve:" + oneMap.Name );
|
|
|
|
if (oneMap.Singleton) {
|
|
// ObjectsByType中存储的都是单例对象
|
|
oneMap.TargetObject = checkByCache( type, ctx );
|
|
}
|
|
else {
|
|
oneMap.TargetObject = rft.GetInstance( type );
|
|
}
|
|
resolvedMap[oneMap.Name] = oneMap;
|
|
|
|
}
|
|
}
|
|
|
|
private static Object checkByCache( Type t, ObjectContext ctx ) {
|
|
if (ctx.ObjectsByType[t.FullName] == null) {
|
|
ctx.ObjectsByType.Add( t.FullName, rft.GetInstance( t ) );
|
|
}
|
|
return ctx.ObjectsByType[t.FullName];
|
|
}
|
|
|
|
|
|
private static void injectObjects( List<MapItem> mapItems, Dictionary<String, MapItem> resolvedMap ) {
|
|
foreach (MapItem item in mapItems) {
|
|
logger.Info( "inject:" + item.Name );
|
|
Dictionary<String, object> maps = item.Map;
|
|
if (maps.Count <= 0) continue;
|
|
|
|
foreach (KeyValuePair<String, object> entry in maps) {
|
|
logger.Info( "------inject key:" + entry.Key.ToString() );
|
|
MapItem referencedItem;// = resolvedMap[entry.Value.ToString()];
|
|
resolvedMap.TryGetValue( entry.Value.ToString(), out referencedItem );
|
|
if (referencedItem != null) {
|
|
ReflectionUtil.SetPropertyValue( item.TargetObject, entry.Key, referencedItem.TargetObject );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 根据容器配置，将依赖关系注入到已创建的对象中
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
public static void Inject( Object obj ) {
|
|
|
|
if (obj == null) return;
|
|
|
|
Type t = obj.GetType();
|
|
|
|
Dictionary<String, MapItem> resolvedMap = ObjectContext.Instance.ResolvedMap;
|
|
|
|
foreach (KeyValuePair<String, MapItem> pair in resolvedMap) {
|
|
|
|
MapItem item = pair.Value;
|
|
if (item.Type.Equals( t.FullName ) == false) continue;
|
|
|
|
Dictionary<String, object> maps = item.Map;
|
|
if (maps.Count <= 0) return;
|
|
|
|
injectObjectSingle( obj, resolvedMap, maps );
|
|
return;
|
|
|
|
}
|
|
}
|
|
|
|
private static void injectObjectSingle( Object obj, Dictionary<String, MapItem> resolvedMap, Dictionary<String, object> maps ) {
|
|
foreach (KeyValuePair<String, object> entry in maps) {
|
|
|
|
logger.Info( "------inject key:" + entry.Key.ToString() );
|
|
MapItem referencedItem;
|
|
resolvedMap.TryGetValue( entry.Value.ToString(), out referencedItem );
|
|
if (referencedItem != null) {
|
|
ReflectionUtil.SetPropertyValue( obj, entry.Key, referencedItem.TargetObject );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|