Spring.Net学习笔记十(打造简易的依赖注入框架)

之前我们学习里一个简易的IoC框架。今天我们接着上次的程序,实现带参数构造函数对象的实例和属性的注入 。原文地址:http://www.cnblogs.com/GoodHelper/archive/2009/11/02/SpringNet_MyDi.html

我感觉这个很有必要对应IOC框架的理解,知道注入的工作原理,对应实际的应用是很有帮助的。

  我们知道可以通过反射获取类的构造函数及参数(GetConstructors方法);可以获取属性和属性的类型(GetProperties方法)。通过Activator的CreateInstance(Type type, params object[] args)方法可以创建带参数构造函数的实例。通过SetValue方法可以给属性赋值,这样一来,我们就上次的代码稍加改造就可以实现属性的注入了。

  下面是完成的代码:


    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

   public class PersonDao
    {
        private int intProp;

        public PersonDao(int intProp)
        {
            this.intProp = intProp;
        }

        public Person Entity { get; set; }

        public override string ToString()
        {
            return "构造函数参数intProp为:" + this.intProp;
        }
    }


public class ObjectFactory
    {
        private IDictionary<string, object> objectDefine = new Dictionary<string, object>();

        private ObjectFactory(string fileName)
        {
            InstanceObjects(fileName);  // 实例IoC容器
            DiObjects(fileName);  // 属性注入
        }

        private static ObjectFactory instance;

        private static object lockHelper = new object();

        public static ObjectFactory Instance(string fileName)
        {
            if (instance == null)
            {
                lock (lockHelper)
                {
                    instance = instance ?? new ObjectFactory(fileName);
                }
            }
            return instance;
        }

        /// <summary>
        /// 实例IoC容器
        /// </summary>
        /// <param name="fileName"></param>
        private void InstanceObjects(string fileName)
        {
            XElement root = XElement.Load(fileName);
            var objects = from obj in root.Elements("object")
                          select obj;

            //无参构造函数
            objectDefine = objects.Where(obj =>
                obj.Element("constructor-arg") == null).ToDictionary(
                    k => k.Attribute("id").Value, 
                    v => 
                    {
                        string typeName = v.Attribute("type").Value;  
                        Type type = Type.GetType(typeName);  
                        return Activator.CreateInstance(type);
                    }
                );

            //有参构造函数
            foreach (XElement item in objects.Where(obj => 
                obj.Element("constructor-arg") != null))
            {                                                                                                                                                  
                string id = item.Attribute("id").Value;
                string typeName = item.Attribute("type").Value;
                Type type = Type.GetType(typeName);
                var args = from property in type.GetConstructors()[0].GetParameters()
                           join el in item.Elements("constructor-arg")
                           on property.Name equals el.Attribute("name").Value
                           select Convert.ChangeType(el.Attribute("value").Value,
                           property.ParameterType);
                object obj = Activator.CreateInstance(type, args.ToArray());
                objectDefine.Add(id, obj);
            }
        }

        /// <summary>
        /// 属性注入
        /// </summary>
        /// <param name="fileName"></param>
        private void DiObjects(string fileName)
        {
            XElement root = XElement.Load(fileName);
            var objects = from obj in root.Elements("object")
                          select obj;

            foreach (KeyValuePair<string,object> item in objectDefine)
            {
                foreach (var el in objects.Where(e => 
                    e.Attribute("id").Value == item.Key).Elements("property"))
                {
                    Type type = item.Value.GetType();
                    //获取属性
                    foreach (PropertyInfo property in type.GetProperties())
                    {
                        if (property.Name == el.Attribute("name").Value)
                        {
                            if (el.Attribute("value") != null)
                            {
                                //设置属性值
                                property.SetValue(item.Value, 
                                    Convert.ChangeType(el.Attribute("value").Value, 
                                    property.PropertyType), null);
                            }
                            else if (el.Attribute("ref") != null)
                            {
                                object refObject = null;

                                if (objectDefine.ContainsKey(el.Attribute("ref").Value))
                                {
                                    refObject = objectDefine[el.Attribute("ref").Value];
                                }
                                //设置关联对象属性
                                property.SetValue(item.Value, refObject, null);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 获取对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public object GetObject(string id)
        {
            object result = null;

            if (objectDefine.ContainsKey(id))
            {
                result = objectDefine[id];
            }

            return result;
        }
    }

<?xml version="1.0" encoding="utf-8" ?>

<objects>

<object id="person" type="SpringNetMyDi.Person, SpringNetMyDi">
    <!--属性值类型注入-->
    <property name="Name" value="Liu Dong"/>
    <property name="Age" value="27"/>

</object>

<object id="personDao" type="SpringNetMyDi.PersonDao, SpringNetMyDi">
    <!--构造器注入-->
    <constructor-arg name="intProp" value="1"/>

<property name="Entity" ref="person" />
    
  </object>

</objects>

class Program
    {
        static void Main(string[] args)
        {
            ObjectFactory factory = ObjectFactory.Instance(@"F:\Exercise\SpringNet\Step1\SpringNet_Lesson9\SpringNetMyDi\Objects.xml");

            PersonDao dao = (PersonDao)factory.GetObject("personDao");

            Console.WriteLine("姓名:" + dao.Entity.Name);
            Console.WriteLine("年龄:" + dao.Entity.Age);
            Console.WriteLine(dao);

            Console.ReadLine();
        }
    }

时间: 2024-11-09 04:59:42

Spring.Net学习笔记十(打造简易的依赖注入框架)的相关文章

AngularJs学习笔记6——四大特性之依赖注入

压缩工具:YUI-compressor 为了优化网页功能,对一些脚本文件进行压缩,比如:删除所有的注释和空格等,简化形参.但是AngularJs模块中可以声明多种组件,如控制器.指令.过滤器.服务等.创建这些模块组件对象时,构造函数是由AngularJS调用的,故不能像普通函数那样,声明任意的形参.使得压缩后的文件无法使用,这时候采用标记式和行内式的数组形式(注意顺序的对应关系),使得压缩后依然可以使用. 依赖:实现功能的时候,如果需要某些模块,模块就是需要的依赖 AngularJS会自动根据依

Spring MVC学习笔记(一)--------准备篇

这一系列笔记将带你一步一步的进入Spring MVC,高手勿喷. 首先你得安装以下的工具: JDK,虽然JDK8已经发布了一段时间了,但是由于我们并不会使用到里面的新特性,所以JDK6以上版本皆可以(需加入到PATH环境变量中): Servlet Container,为了能运行WEB应用程序,因此需要一个Web Container,这里我们建议Tomcat即可: IDE,一个好的IDE不仅能提高你开发的效率,还能降低你学习的成本,我们选择的是IntelliJ: 构建工具,推荐使用Gradle,它

Spring MVC 学习笔记(二):@RequestMapping用法详解

一.@RequestMapping 简介 在Spring MVC 中使用 @RequestMapping 来映射请求,也就是通过它来指定控制器可以处理哪些URL请求,相当于Servlet中在web.xml中配置 <servlet>     <servlet-name>servletName</servlet-name>     <servlet-class>ServletClass</servlet-class> </servlet>

Spring Batch学习笔记二

此系列博客皆为学习Spring Batch时的一些笔记: Spring Batch的架构 一个Batch Job是指一系列有序的Step的集合,它们作为预定义流程的一部分而被执行: Step代表一个自定义的工作单元,它是Job的主要构件块:每一个Step由三部分组成:ItemReader.ItemProcessor.ItemWriter:这三个部分将执行在每一条被处理的记录上,ItemReader读取每一条记录,然后传递给ItemProcessor处理,最后交给ItemWriter做持久化:It

Swift学习笔记十二:下标脚本(subscript)

下标脚本就是对一个东西通过索引,快速取值的一种语法,例如数组的a[0].这就是一个下标脚本.通过索引0来快速取值.在Swift中,我们可以对类(Class).结构体(structure)和枚举(enumeration)中自己定义下标脚本的语法 一.常规定义 class Student{ var scores:Int[] = Array(count:5,repeatedValue:0) subscript(index:Int) -> Int{ get{ return scores[index];

第十七篇:实例分析(3)--初探WDDM驱动学习笔记(十)

续: 还是记录一下, BltFuncs.cpp中的函数作用: CONVERT_32BPP_TO_16BPP 是将32bit的pixel转换成16bit的形式. 输入是DWORD 32位中, BYTE 0,1,2分别是RGB分量, 而BYTE3则是不用的 为了不减少color的范围, 所以,都是取RGB8,8,8的高RGB5, 6, 5位, 然后将这16位构成一个pixel. CONVERT_16BPP_TO_32BPP是将16bit的pixel转换成32bit的形式 输入是WORD 16BIT中

[Spring MVC]学习笔记--DispatcherServlet

在上一篇我们介绍了Servlet,这一篇主要来看一下MVC中用到的DispatcherServlet(继承自HttpServlet). 1. DispatcherServlet在web.xml中被声明. <web-app> <servlet> <servlet-name>example</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet&l

初探swift语言的学习笔记十(block)

作者:fengsh998 原文地址:http://blog.csdn.net/fengsh998/article/details/35783341 转载请注明出处 如果觉得文章对你有所帮助,请通过留言或关注微信公众帐号fengsh998来支持我,谢谢! 在前面一些学习中,原本把闭包给理解成了block尽管有很多相似之处,但block还是有他自己的独特之外.近日,在写oc/swift混合编码时,有时候需要swift回调oc,oc回调swift . 因此我把swift中的 block 常见的声明和写

Swift学习笔记十:属性

1.存储属性       1. 作为特定类或结构实例的一部分,存储属性存储着常量或者变量的值.存储属性可分为变量存储属性(关键字var描述)和常量存储属性(关键字let描述). struct student{ let name = "" var score = 0 } let a = student(name:"小笨狼",score:96)           注意:                ① 定义储存属性时,需要为每一个属性定义一个默认值.在初始化的时候,