程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 我理解的IOC技術在Java和C#中比較分析

我理解的IOC技術在Java和C#中比較分析

編輯:關於JAVA
 

  一直想用心寫這個系列的文章,其實看得越多,也就越覺得自己在這方面的功力太淺,也就越不想班門弄斧啦,作為一個開篇,我想把這個技術深層次化,在之前的.net的一個MVC系列文章其實已經涉及到了,只是.net在這方面的應用不如java來得這麼猛烈,這麼酣汗淋漓,所以也就下定決心,這一階段針對這一個技術點進行深層次的剖析。

  IOC,英文全稱Inversion of Control,中文直譯控制反轉,一般我們稱之為“依賴注入”原則,在我還未過多涉足java領域時,在C#語言24個設計模式中(參見《大話設計模式》)有一個依賴倒轉原則,作為一個設計模式的原則而不是一個模式。在接觸java之後,尤其是spring框架後,被稱之為“依賴注入”IOC設計模式。其實大體的意思和意義都是差不多的,只是在我看來,在C#領域對這個技術的應用沒有那麼廣泛,限於.NET技術的先天性,我很少看到這方面的巨作,也許是我太膚淺。在我上次寫基於.NET的MVC ProDinner系列文章時候,查找這方面的文章,幾乎是為零,只能自己去看MVC源碼或者Castle 項目源碼。

  首先看看《大話設計模式》中基於C#語言如何诠釋這門藝術的。原著由維修計算機入題,在我們日常生活中,我們很自然地,提高計算機速度需要更高的CPU,需要更快的系統響應度就需要更好的內存,需要更大的存儲介質,就需要擴大硬盤,在這一系列的活動中,於是我們就自然而然的發現,計算機速度依賴CPU,在CPU的使用中我們從來不關心CPU是怎麼設計出來的,我們只需要關注這是Intel還是AMD的CPU,因為他決定了你的主板類型,當確定了CPU之後,我們只需關注你需要使用那款CPU,因為接口主板都是一樣的,也即是說,大的功能不會去關注具體每一款產品的實現,而只需要關注產品與產品之間的標准化接口。由此引出來這個原則的定義:

  A、高層模塊不應該依賴低層模塊,兩個都應該依賴抽象

  B、抽象不應該依賴細節,細節應該依賴抽象

  這麼講其實是比較抽象的,具體到代碼中實際上就是,層於層之間,各模塊間,各項目間都應該使用接口層來完成模塊的融合。 當某個角色(可能是一個對象實例,調用者)需要另一個角色(另一個對象實例,被調用者)的協助時,在傳統的程序設計過程中,通常由調用者來創建被調用者的實例。而控制反轉中創建被調用者的工作不再由調用者來完成。創建被調用者 實例的工作通常由特定的容器來完成,然後注入調用者,因此也稱為依賴注入。

  廢話不多說,理論講得再精彩最終看代碼實現,依據我對這些該概念的理解,我們一起看基於C#語言寫出的實例:

  需求場景:

      父親在完成一件事情的時候,由於各方面原因需要自己的子女幫忙才能完成,所以,父親需要去調動自己的兒子或者女兒才能完成這件事情

      類型設計:

  接口 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來實現容器,實現步奏:

  1、建立需要實現注入的JavaBean,注入類Person和容器類Persons

  2、建立類似spring框架的application.xml配置文件,將依賴的JavaBean和相應注入的屬性配置在xml文件中,我們這裡取名叫 IocApplication.xml

  3、實現注入容器的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

  結束語:

  這篇文章我們暫且不來比較依賴注入和反轉的區別,依賴反轉和依賴注入很多程序員把這兩個概念當成一個理解,認為只是不同的解釋,其實細分還是有區別的
  1、依賴注入是從應用程序的角度在描述,也就是說,應用程序依賴容器創建並注入它所需要的外部資源;而控制反轉是從容器的角度在描述,容器控制應用程序,由容器反向的向應用程序注入應用程序所需要的外部資源。

  2、IOC,控制反轉是軟件運行時體現出來的一個特征:如果對象A運行時依賴於對象B,但A並不去創建B,而是從外界直接取得B。也就是說,一個對象並不是自己去創建它所依賴的其它對象。DI,依賴注入是控制反轉的一種實現手段。如上面的例子,B的取得並不需要A的干涉,而是利用某些框架在通過構造參數或屬性設置來實現。

關於這些這裡就不展開敘述,後面我們再詳細討論,這節主要討論依賴注入,我們首先在這節暫時認為這是一個相同的概念。作為概述,首先我們了解下IOC概念,再看看java和C#在這一概念上的運用比較。

 
  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved