我理解的IOC技术在Java和C#中比较分析

时间 2019-11-30

标签理解 ioc 技术 java c# 比较分析栏目 Java 繁體版

原文原文链接

　　一直想用心写这个系列的文章，其实看得越多，也就越以为本身在这方面的功力太浅，也就越不想班门弄斧啦，做为一个开篇，我想把这个技术深层次化，在以前的.net的一个MVC系列文章其实已经涉及到了，只是.net在这方面的应用不如java来得这么猛烈，这么酣汗淋漓，因此也就下定决心，这一阶段针对这一个技术点进行深层次的剖析。html

　　IOC，英文全称Inversion of Control，中文直译控制反转，通常咱们称之为“依赖注入”原则，在我还未过多涉足java领域时，在C#语言24个设计模式中（参见《大话设计模式》）有一个依赖倒转原则，做为一个设计模式的原则而不是一个模式。在接触java以后，尤为是spring框架后，被称之为“依赖注入”IOC设计模式。其实大致的意思和意义都是差很少的，只是在我看来，在C#领域对这个技术的应用没有那么普遍，限于.NET技术的先天性，我不多看到这方面的巨做，也许是我太肤浅。在我上次写基于.NET的MVC ProDinner系列文章时候，查找这方面的文章，几乎是为零，只能本身去看MVC源码或者Castle 项目源码。java

　　首先看看《大话设计模式》中基于C#语言如何诠释这门艺术的。原著由维修计算机入题，在咱们平常生活中，咱们很天然地，提升计算机速度须要更高的CPU，须要更快的系统响应度就须要更好的内存，须要更大的存储介质，就须要扩大硬盘，在这一系列的活动中，因而咱们就天然而然的发现，计算机速度依赖CPU，在CPU的使用中咱们历来不关心CPU是怎么设计出来的，咱们只须要关注这是Intel仍是AMD的CPU，由于他决定了你的主板类型，当肯定了CPU以后，咱们只需关注你须要使用那款CPU，由于接口主板都是同样的，也便是说，大的功能不会去关注具体每一款产品的实现，而只须要关注产品与产品之间的标准化接口。由此引出来这个原则的定义：程序员

　　A、高层模块不该该依赖低层模块，两个都应该依赖抽象spring

　　B、抽象不该该依赖细节，细节应该依赖抽象数据库

　　这么讲实际上是比较抽象的，具体到代码中实际上就是，层于层之间，各模块间，各项目间都应该使用接口层来完成模块的融合。当某个角色(多是一个对象实例，调用者)须要另外一个角色(另外一个对象实例，被调用者)的协助时，在传统的程序设计过程当中，一般由调用者来建立被调用者的实例。而控制反转中建立被调用者的工做再也不由调用者来完成。建立被调用者实例的工做一般由特定的容器来完成，而后注入调用者，所以也称为依赖注入。设计模式

　　废话很少说，理论讲得再精彩最终看代码实现，依据我对这些该概念的理解，咱们一块儿看基于C#语言写出的实例：app

　　需求场景：框架

父亲在完成一件事情的时候，因为各方面缘由须要本身的子女帮忙才能完成，因此，父亲须要去调动本身的儿子或者女儿才能完成这件事情eclipse

类型设计：函数

　　接口 Iperson为被调用者的基类型

类 Father 调用者

类 Son 被调用者

　　类 Daughter 被调用者

　　类 Container 依赖注入容器

程序分析：

Father类经过调用抽象层接口，来完成这个操做，至于调用儿子仍是女儿咱们在构造函数中完成类型的选择。也就是说Father是调用者，Son和Daughter是被调用者，Container是依赖注入的生成容器。负责将调用者Son或者Daughter对象实例化给调用者。

　　.NET 程序目录结构：

　　打开visual studio 创建控制台应用程序，接口层代码实现：

1     //接口层
2     public interface Iperson
3     {
4         void operation();
5     }

　　调用者代码实现：

 1     //调用者实现类
 2     public class Father
 3     {
 4         Iperson iperson;
 5 
 6         Container container = new Container();
 7 
 8         public Father(String typeName)
 9         {
10             iperson = container.GetApplication(typeName);
11         }
12         public void operation()
13         {
14             iperson.operation();
15         }
16     }

Container 在这里我直接new出实例了，看到这个代码熟悉java spring框架的同窗就似曾相识了，通常是用@autowired来修饰依赖注入的操做句柄。Father类中的operation方法并无本身去实现任何操做，而是调用了iperson的操做来实现本身的方法，而iperson只是一个接口类型，须要具体的实现类，代码才能运行起来，咱们看iperson的两个实现层：

    //被调用者类 ipseron实现层
    public class Son:Iperson
    {
        public void operation()
        {
            Console.WriteLine("son is the operator");        
        }
    }

    //被调用者之二
    public class Daughter:Iperson
    {
        public void operation()
        {
            Console.WriteLine("daughter is the operator");
        }
    }

Conatiner是实现容器，原理其实很简单，反射技术，反射原理进行不一样的封装其实就造成了不一样的技术框架，java spring的ioc核心离不开反射，许多的数据库mapper框架一样也离不开反射，看看代码实现：

    //生成实例容器
    public class Container
    { 
        
        public Iperson GetApplication(String typeName)
        {
          return (Iperson) Activator.CreateInstance(Type.GetType(typeName));
        }
    }

固然，我这是最基本的反射实现了，在生成化产品化的框架中反射远没有这么简单，但原理都是相同的。好，看下测试类实现代码：

    class Program
    {
        static void Main(string[] args)
        {
            //调用son
            Father fa = new Father("IOCblog.Son");
            fa.operation();

            //调用daughter
            fa = new Father("IOCblog.Daughter");
            fa.operation();
        }
    }

程序运行结果：

代码写到这里对这个概念有所掌握的同窗，其实会是有共鸣的，这是依赖注入最基本的实现了，平常项目开发中基于框架级别来实现这种模式思想，咱们不少时候是用修饰符或者配置文件，典型的就是java下面的spring的实现。java spring框架可没那么简单，spring两大核心ioc和aop，实现的手段无非也是如此，但不一样的是思想！思想！我这里如若再用java套spring框架来作示例实现java下的IOC的思想，确定也就没人有兴趣继续看下去了，这篇文章的含金量就没那么诱人啦，那么咱们来高级点的：

　　基于java代码的模拟spring框架IOC实现

　　实现java下的ioc毫无疑问，咱们首先专业术语就换成了，咱们须要JavaBean来实现注入，须要factory来实现容器，实现步奏：

　　一、创建须要实现注入的JavaBean，注入类Person和容器类Persons

　　二、创建相似spring框架的application.xml配置文件，将依赖的JavaBean和相应注入的属性配置在xml文件中，咱们这里取名叫 IocApplication.xml

　　三、实现注入容器的factory类，主要负责读配置文件->依据配置文件进行对象实例化->放入persons map集合当中，以备调用。

java程序目录结构：

大致实现思路如上所述，好，废话很少说，看看代码如何实现，第一步和第二步代码以下（切换到eclipse下，创建java应用程序）：

package com.ioc.bean;

//被调用注入类
public class Person {
    
    private String name;
    public String getName()
    {
        return this.name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }

}

package com.ioc.bean;

//beans类
public class Persons {

    private Person son;
    public Person getSon()
    {
        return this.son;
    }
    
    public void setSon(Person son)
    {
        this.son = son;
    }
    
    private Person daughter;
    public Person getDaughter()
    {
        return this.daughter;
    }
    
    public void setDaughter(Person daughter)
    {
        this.daughter = daughter;
    }
}

实现的容器factory代码量比较大，这里就不依依贴出，全部的源代码都在附件中可自由下载，这里主要分析几个关键步奏:

实现容器，主要负责一件事件，经过配置的xml，对相应的javabean进行反射，生成实例化对象，存入map中，xml配置实现：

<?xml version="1.0" encoding="UTF-8"?>  
<beans>  
    <bean id="son" class="com.ioc.bean.Person">  
        <property name="name">  
            <value>mark</value>  
        </property>    
    </bean>  
    <bean id="daughter" class="com.ioc.bean.Person">  
        <property name="name">  
            <value>cindy</value>  
        </property>  
    </bean>  
    <bean id="father" class="com.ioc.bean.Persons">  
        <property name="son">  
            <ref bean="son" />  
        </property>  
        <property name="daughter">  
            <ref bean="daughter" />  
        </property>  
    </bean>      
</beans>

容器实现map操做代码：

    private Map<String,Object> beanMap=new HashMap<String,Object>();  
      
    /** 
     * 初始化xml文件 
     * */  
    public void init(String xmlUrl){  
        SAXReader  saxReader=new SAXReader();  
        File file=new File(xmlUrl);  
        try{  
            saxReader.addHandler("/beans/bean",new BeanHandler());  
            saxReader.read(file);  
        }  
        catch(DocumentException e){  
            System.out.println(e.getMessage());  
        }  
    }  
      
    /** 
     * 根据beanid来获取bean 
     * */  
    public Object getBean(String beanId){  
        Object obj=null;  
        obj=beanMap.get(beanId);  
        return obj;  
          
    }

BeanHandler毫无疑问就是具体去操做IocApplication.xml文件的操做类，代码比较长，能够下载附件源代码查看。
好，看下测试类代码：

package com.ioc.test;

import com.ioc.bean.Person;
import com.ioc.factory.BeanFactory;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String xmlUrl="src/IocApplication.xml";  
        BeanFactory factory=new BeanFactory();  
        factory.init(xmlUrl);  
        Person me=(Person)factory.getBean("son");  
        System.out.println("Son's name:"+me.getName()); 
    }

}

程序运行结果：

java 模拟spring实现，能够参考这篇文章：http://only1.iteye.com/blog/733550

　　结束语：

　　这篇文章咱们暂且不来比较依赖注入和反转的区别，依赖反转和依赖注入不少程序员把这两个概念当成一个理解，认为只是不一样的解释，其实细分仍是有区别的
　　一、依赖注入是从应用程序的角度在描述，也就是说，应用程序依赖容器建立并注入它所须要的外部资源；而控制反转是从容器的角度在描述，容器控制应用程序，由容器反向的向应用程序注入应用程序所须要的外部资源。

　　二、IOC，控制反转是软件运行时体现出来的一个特征：若是对象A运行时依赖于对象B，但A并不去建立B，而是从外界直接取得B。也就是说，一个对象并非本身去建立它所依赖的其它对象。DI，依赖注入是控制反转的一种实现手段。如上面的例子，B的取得并不须要A的干涉，而是利用某些框架在经过构造参数或属性设置来实现。

关于这些这里就不展开叙述，后面咱们再详细讨论，这节主要讨论依赖注入，咱们首先在这节暂时认为这是一个相同的概念。做为概述，首先咱们了解下IOC概念，再看看java和C#在这一律念上的运用比较。

写一篇博文基本是一个礼拜的积累，雕琢，不容易，无私的奉献转载注明出处，http://www.cnblogs.com/aspnetdream/p/4035677.html。

最后附上个人源代码

Java代码 http://files.cnblogs.com/aspnetdream/iocblog.rar

C#代码 http://files.cnblogs.com/aspnetdream/Csharp_IOCblog.rar