实现一个简易IOC容器

最新推荐文章于 2023-10-07 23:10:14 发布
最新推荐文章于 2023-10-07 23:10:14 发布
阅读量119 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/ylws/p/3301425.html

本文，实现了一个简易的IOC容器，主要供学习使用。

首先抽象需要实现的功能，容器主要由两部分组成
1.注册
2.获取实例

        /// <summary>
        /// 注册 基类/接口->实际类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TReal"></typeparam>
        void Register<T, TReal>();

        /// <summary>
        /// 注册 实例
        /// </summary>   
        /// <typeparam name="obj"></typeparam>
        void RegisterInstances(object obj);

        /// <summary>
        /// 注册 实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        void RegisterInstances<T>(object obj);

        /// <summary>
        /// 注册 泛型
        /// “开放”类型 只能存在于typeof操作中
        /// </summary>
        /// <param name="t1"></param>
        /// <param name="t2"></param>
        void RegisterGeneric(Type t1, Type t2);

        /// <summary>
        /// 获取类型实例
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        T GetInstances<T>();

为了简单起见，本文使用静态的Dictionary作为存放容器，XML配置部分未实现，

具体实现如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace Core.IOC
{
    public class IOCManage
    {
        /// <summary>
        /// 多构造函数 创建对象规则
        /// 默认为 MultipleCtor.Longest
        /// </summary>
        public static MultipleCtor MultipleType = MultipleCtor.Longest;

        /// <summary>
        /// 类型字典 存放 声明类型->实际类型
        /// </summary>
        private static Dictionary<Type, Type> _types = new Dictionary<Type, Type>();

        /// <summary>
        /// 实例字典
        /// </summary>
        private static Dictionary<Type, object> _instances = new Dictionary<Type, object>();




        static IOCManage()
        {
            //TODO:XML配置加载
        }




        /// <summary>
        /// 创建类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static T GetInstances<T>()
        {
            return (T)Get(typeof(T));
        }

        /// <summary>
        /// 该方法供 属性注入 中递归调用
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static object Get(Type type)
        {
            object obj = InjectCtor(type);
            InjectProperty(obj);
            return obj;
        }

        #region 构造器注入


        /// <summary>
        /// 构造器注入
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static object InjectCtor(Type type)
        {
            //查找 对象字典中是否有现成对象可以使用
            object obj;
            if (_instances.TryGetValue(type, out obj))
                return obj;


            //查找 类型字典 获取要创建的实际类型   
            Type t = GetRealType(type);
            if (t == null || !t.IsClass || t.IsAbstract) return null;


            //对构造函数的几种处理方法
            ConstructorInfo[] ctors = t.GetConstructors();
            if (ctors.Length == 0)
            {
                //throw new MissingMethodException("找不到匹配的公共构造函数");
            }
            else if (ctors.Length == 1)
            {
                obj = CreateObj(t, ctors[0]);
            }
            else if (ctors.Length > 1)
            {
                if (MultipleType == MultipleCtor.Error) { throw new CtorMultipleException("构造函数多余一个！"); }
                if (MultipleType == MultipleCtor.Attribute)
                {
                    foreach (var ctor in ctors)
                    {
                        if (ctor.IsDefined(typeof(AutoCtorAttribute), false))
                        {
                            obj = CreateObj(t, ctor);
                            if (obj != null) break;
                        }
                    }
                }
                if (MultipleType == MultipleCtor.Longest || obj == null)//如果标记为特性模式 却创建失败，重新执行
                {
                    var _ctors = ctors.OrderByDescending(a => a.GetParameters().Length);
                    foreach (var ctor in _ctors)
                    {
                        obj = CreateObj(t, ctor);
                        if (obj != null) break;
                    }
                }
            }
            _instances[type] = obj;
            return obj;
        }


        /// <summary>
        /// 查找实际类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static Type GetRealType(Type type)
        {
            Type t;
            if (!_types.TryGetValue(type, out t))//查找 类型字典，找出实际要创建的类型
            {
                t = GetGenericType(type);
            }
            return t;
        }

        /// <summary>
        /// 获取泛型类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static Type GetGenericType(Type type)
        {
            //假设 字典中存的是 typeof(IList<>)->typeof(List<>)
            //现在需要从IList<string>创建List<string>对象
            Type t = null;
            if (type.IsGenericType)
            {
                if (_types.TryGetValue(type.GetGenericTypeDefinition(), out t) && t.IsGenericType)//获取“开放” 类型 字典中查找                
                {
                    t = t.MakeGenericType(type.GetGenericArguments());//获取 实际需要创建的“封闭”类型
                }
            }
            return t;
        }

        /// <summary>
        /// 通过构造函数类型创建实例
        /// </summary>
        /// <param name="type"></param>
        /// <param name="t"></param>
        /// <param name="ctor"></param>
        /// <returns></returns>
        private static object CreateObj(Type type, ConstructorInfo ctor)
        {
            ParameterInfo[] @params = ctor.GetParameters();
            int length = @params.Length;
            object[] args = new object[length];

            for (int i = 0; i < length; i++)
            {
                args[i] = InjectCtor(@params[i].ParameterType);//获取参数类型 递归调用创建方法
            }
            try
            {
                return Activator.CreateInstance(type, args);
            }
            catch
            {
                return null;
            }
        }

        #endregion

        #region 属性注入

        /// <summary>
        /// 属性注入
        /// 通过[AutoWrite]特性标记
        /// </summary>
        /// <param name="obj"></param>
        private static void InjectProperty(object obj)
        {
            if (obj != null)
            {
                PropertyInfo[] properties = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);//只查找公开属性

                foreach (var property in properties)
                {
                    AutoWriteAttribute autoWrite = (AutoWriteAttribute)Attribute.GetCustomAttribute(property, typeof(AutoWriteAttribute));
                    if (autoWrite != null)
                    {
                        object value = Get(autoWrite.RealType);
                        InjectProperty(obj);//递归注入
                        property.SetValue(obj, value, null);
                    }
                }
            }
        }

        #endregion

        #region 注册

        /// <summary>
        /// 注册 基类/接口->实际类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TReal"></typeparam>
        public static void Register<T, TReal>() where TReal : T
        {
            _types[typeof(T)] = typeof(TReal);
        }

        /// <summary>
        /// 注册 类型
        /// </summary>   
        /// <typeparam name="T"></typeparam>
        public static void RegisterType<T>()
        {
           _types[typeof(T)] = typeof(T);
        }

        /// <summary>
        /// 注册 实例
        /// </summary>   
        /// <typeparam name="T"></typeparam>
        public static void RegisterInstances(object obj)
        {
            if (obj == null) throw new ArgumentNullException("obj 不能为null！");
            _instances[obj.GetType()] = obj;
        }

        /// <summary>
        /// 注册 实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        public static void RegisterInstances<T>(object obj)
        {
            Type type = typeof(T);
            Type t = obj.GetType();

            if (!type.IsAssignableFrom(t))  //判断obj类型是否 等于/继承/实现 T
            {
                throw new RegisterException(string.Format("obj的实际类型{0}与泛型类型{1}不匹配！", t.Name, type.Name));
            }
            _instances[type] = obj;
        }

        /// <summary>
        /// 注册 泛型
        /// “开放”类型 只能存在于typeof操作中
        /// </summary>
        /// <param name="t1"></param>
        /// <param name="t2"></param>
        public static void RegisterGeneric(Type t1, Type t2)
        {
            //判断t1是否 等于/继承/实现t2 
            //if (!t1.IsAssignableFrom(t2))
            //{
            Type _t1 = t1;
            Type _t2 = t2;

            //if (t1.IsGenericTypeDefinition || t2.IsGenericTypeDefinition)//泛型特殊处理
            //{
            //TODO:判断泛型是否存在 继承 实现 关系

            //通过创建泛型的“封闭”类型判断继承关系
            //todo:暂时实现不了
            //Type _t1 = t1.MakeGenericType(typeof(object));//泛型约束
            //Type _t2 = t2.MakeGenericType(typeof(object));//泛型约束
            //if (!_t1.IsAssignableFrom(_t2))
            //{
            //    throw new RegisterException(string.Format("参数类型{0}与{1}不匹配！", t1.Name, t2.Name));
            //}
            //}
            //else
            //{
            //throw new RegisterException(string.Format("参数类型{0}与{1}不匹配！", t1.Name, t2.Name));
            //}
            //}
            _types[t1] = t2;
        }

        #endregion
    }
}

　　其中使用到的相关类

    public class AutoWriteAttribute : Attribute
    {
        public Type RealType { get; private set; }
        public AutoWriteAttribute(Type type) { this.RealType = type; }
    }

    public class AutoCtorAttribute : Attribute
    {
        
    }

    public class CtorMultipleException : Exception
    {
        public CtorMultipleException(string message) : base(message) { }
    }

    /// <summary>
    /// 针对多个构造函数的创建方法
    /// </summary>
    public enum MultipleCtor
    {
        /// <summary>
        /// 按照 参数数量 依次调用构造函数 直到创建成功
        /// </summary>
        Longest,
        /// <summary>
        /// 抛出CtorMultipleException异常
        /// </summary>
        Error,
        /// <summary>
        /// 优先使用特性标记的构造函数 然后按照 Longest;
        /// </summary>
        Attribute
    }

    public class RegisterException : Exception
    {
        public RegisterException(string message) : base(message) { }
    }

　　test

    class Program
    {
        static void Main(string[] args)
        {
            IOCManage.RegisterInstances(new A { Name = "A" });
            IOCManage.RegisterInstances<B>(new B { Name = "B" });
            IOCManage.RegisterType<C>();
            C c = IOCManage.GetInstances<C>();

            Console.Read();
        }
    }

    class A { public string Name { get; set; } }
    class B { public string Name { get; set; } }
    class C
    {
        private A a;
        private B b;
        public C(A a, B b)
        {
            this.a = a;
            this.b = b;
        }
    }

　　

转载于:https://www.cnblogs.com/ylws/p/3301425.html

R芮R
关注
实现一个简易的IoC容器
水木今山的博客
03-20 416
Simple IoC 仿照 Spring 实现的一个简易版的 IoC 容器。 项目地址：simple-ioc Features 支持根据指定的路径从文件系统中获取资源 支持XSD模式的XML验证 支持<property/>标签以及value与ref属性（即字符串与引用类型的属性注入） 支持单例与原型Bean，并通过三级缓存解决了单例Bean的循环依赖问题 Blog 资源加载 注册...
三步实现简易的IOC
qq_45040387的博客
08-29 730
IOC是什么 IOC（Inversion Of Control）是一种设计思想，意思是控制反转，这个思想的目的是为了自动地管理类的生命周期以及所有类之间的依赖关系。传统Java SE程序中如果我们需要在一个实例中引用另一个对象，一般是直接用new关键字直接创建一个对象来构建这个依赖关系，这种依赖构建方式使程序之间具有很强的耦合关系，甚至程序不能独立编译，难以进行单元测试。IOC设计思想可以让我们实现程序之间的解耦，很大程度地提高程序的灵活性和可维护性。以前是对象控制其他对象，现在将所有对象的控制权都交给了I
简易 Ioc
long6172940的专栏
01-24 314
第一部分 加载指定路径下的dll         ///         /// 加载插件         ///         public void LoadAllPlugs()         {             //获取插件目录(plugins)下所有文件             string[] files = Directory.GetFiles(Appl
简易IOC实现
Braveyzx的博客
12-08 318
实现IOC容器，依赖注入 import java.io.File; import java.io.FileFilter; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.net.URL; import java.util.*; import java.util.concurrent.ConcurrentHashMap; /** * 简易在简易 IOC 容器 */ public
（一）实现一个简易版IoC容器【手撸Spring】
MarkusZhang的博客
10-07 650
相信大家在看本篇文章的时候，对IoC应该有一个比较清晰的理解，我在这里再重新描述下：它的作用就是实现一个容器将一个个的Bean（这里的Bean可以是一个Java的业务对象，也可以是一个配置对象）统一管理起来。在Java中，我们创建一个对象最简单的方法是使用new关键字。Spring框架的IoC容器则是将创建Bean的动作与使用Bean解耦，将应用层程序员无需关注底层对象的构建以及其生命周期，以便更好的专注于业务开发。本节我们则开始进入手写Spring框架的第一步：实现一个最简易的IoC容器。
简易ioc容器实现
红豆和绿豆的博客
02-08 210
简单ioc
一步步动手实现一个简易的IOC容器
weixin_46120888的博客
12-18 729
手动实现IOC容器
手动实现一个ioc容器.zip
05-31
在压缩包子文件"my-spring-ioc-master"中，可能包含了一个完整的示例项目，该项目演示了如何手动构建一个简易的Spring IOC容器。项目中可能包括以下部分： - **BeanDefinition**: 表示Bean定义的类，存储Bean的信息...
IOC容器简单实现
12-27
本篇文章将深入探讨如何使用Java实现一个简单的IOC容器。 ### 1. IOC容器的基本概念 IOC的核心思想是“依赖注入”（Dependency Injection，DI）。在传统的编程中，对象A依赖于对象B，通常在A的构造函数或者初始化...
java代码实现简易版IOC容器！.docx
11-22
在这个简易版的Java IOC容器实现中，我们将探讨如何通过自定义注解和反射机制来构建一个基础的IoC容器。 首先，我们有两个自定义注解：`@MyComponent` 和 `@MyAutowired`。 1. `@MyComponent` 是一个类型注解，...
Java实现简易IOC容器及其功能探究
描述中提到这是一个“简单的IOC容器的java实现”，说明该文档或代码示例旨在展示如何用Java语言编写一个基本的IOC容器。实现可能包括容器的初始化、对象的创建、依赖关系的解析以及对象生命周期的管理等核心功能。 ...
Java反射技术实现简易IOC容器解析
3. 实现IOC容器：这是一个关键部分，我们需要编写一个类来加载XML配置文件，解析其中的对象信息，并使用Java反射API来创建对象。这个类应该包含一个Map来存储创建的对象，键是XML中的`id`，值是对应创建的对象。 ``...
自己动手实现简易ioc (1)
maqinchaoTnT的博客
08-31 311
1.注解部分 Autowired:标志需要导入的属性 package com.mqc.ioc.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lan...
简单IOC实现
helloworlddm的博客
04-29 943
IOC基本原理 IOC：控制反转，是Spring框架的核心，能够实现动态注入实例的功能。在Spring中，这个过程由Spring框架帮助我们完成。我们只需要配置好相应的XML文件或者使用注解，Spring会自动进行注入。 IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致...
自己动手实现一个简单的 IOC
ignore
12-05 2499
再上一篇文章中，楼主和大家一起分析spring的 IOC 实现，剖析了Spring的源码，看的出来，源码异常复杂，这是因为Spring的设计者需要考虑到框架的扩展性，健壮性，性能等待元素，因此设计的很复杂。楼主在最后也说要实现一个简单的 IOC，让我们更加深刻的理解IOC，因此，有了这篇文章。当然我们是仿照Spring 的 IOC，因此代码命名和设计基本是仿照spring的。我们将分为几步来编写简易
根据虹软实现的 人脸检测、追踪、识别、年龄检测、性别检测 的JAVA解决方案
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/vxfyv (最新版、最全版本)根据虹软实现的 人脸检测、追踪、识别、年龄检测、性别检测 的JAVA解决方案
matlab YALMIP、GLPK安装资源
最新发布
09-11
matlab的YALMIP、GLPK安装包，内置YALMIP、GLPK，直接将分别其添加到matlab的toolbox、路径中即可（matlab主页-设置路径-添加并包含子文件夹-YALMIP；matlab主页-设置路径-添加文件夹-github_repo）
【scratch3.0少儿编程-游戏原型-动画-项目源码】打砖块.zip
09-11
资源说明： 1：本资料仅用作交流学习参考，请切勿用于商业用途。 2：一套精品实用scratch3.0少儿编程游戏、动画源码资源，无论是入门练手还是项目复用都超实用，省去重复开发时间，让开发少走弯路！ 更多精品资源请访问 https://blog.youkuaiyun.com/ashyyyy/article/details/146464041
使用 OpenCV 技术实现人脸检测的方法与过程
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/o7o7f 运用 OpenCV 这一计算机视觉库来开展人脸检测相关的操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值