手寫Spring之DI依賴注入

Cruise_Chan 發布于2019-08-15 14:15 / 1848人閱讀

摘要：如感興趣，可移步手寫之基于動態創建對象手寫之基于注解動態創建對象今天將詳細介紹如何手寫依賴注入，在運行過程中如何動態地為對象的屬性賦值。完成后在中會有相關的包出現進行注入前需要創建工廠，在運行時從工廠中取出對象為屬性賦值。

前兩篇文章介紹了關于手寫Spring IOC控制反轉，由Spring工廠在運行過程中動態地創建對象的兩種方式。如感興趣，可移步：

手寫Spring之IOC基于xml動態創建對象

手寫Spring之IOC基于注解動態創建對象

今天將詳細介紹如何手寫Spring DI依賴注入，在運行過程中如何動態地為對象的屬性賦值。

首先還是創建項目，用于本次測試需要使用到junit，因此創建的是Maven項目，方便添加依賴jar包，JDK環境還是1.7：

接下來在pom.xml文件中添加junit的依賴坐標：


  junit
  junit
  4.10
  test

第一次添加時，若本地倉庫中沒有此版本的jar包，Maven會根據配置的鏡像聯網下載，默認是去中心倉庫下載，中心倉庫的服務器在國外，下載速度較慢，建議修改配置文件連接阿里云的Maven鏡像倉庫下載，速度較快，如何配置在此不多贅述。你也可以根據自己本地倉庫已有的junit版本對依賴坐標的版本進行修改，這樣就可以直接使用本地倉庫的jar包，不用耗時連外網去下載了。

完成后在Maven Dependencies中會有相關的jar包出現：

進行DI注入前需要創建工廠，在運行時從工廠中取出對象為屬性賦值。因此先做一些準備工作，創建幾個要用到的注解：

MyComponent注解內容如下：

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**@Target 屬性用于注明此注解用在什么位置,
 * ElementType.TYPE表示可用在類、接口、枚舉上等*/
@Target(ElementType.TYPE)
/**@Retention 屬性表示所定義的注解何時有效,
 * RetentionPolicy.RUNTIME表示在運行時有效*/
@Retention(RetentionPolicy.RUNTIME)
/**@interface 表示注解類型*/
public @interface MyComponent {
    /**為此注解定義scope屬性*/
    public String scope() default "";
}

MyAutowired注解內容如下：

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAutowired {

}

MyValue注解內容如下：

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyValue {
    /**定義value屬性*/
    public String value();
}

接下來創建實體類：

User實體類內容如下，實體類中的屬性值暫用注解方式寫死作為測試(實際中并不會這么用)，此實體類暫時為單例類(不注明scope屬性默認為單例模式)：

@MyComponent
public class User {
    @MyValue("1")
    private Integer id;
    @MyValue("zhangsan")
    private String name;
    @MyValue("zhangsan")
    private String password;
    
    public User() {
        System.out.println("無參構造方法執行");
    }
    
    public void login(){
        System.out.println("用戶登錄：id=" + id + ", name=" + name + ", password=" + password);
    }
    
    //setters和getters...
}

然后創建UserService類，在Service類中使用依賴注入User：

UserService內容如下：

package service;

import annotation.MyAutowired;
import annotation.MyComponent;
import entity.User;
@MyComponent
public class UserService {

    @MyAutowired
    User user1;
    
    @MyAutowired
    User user2;
    
    public void userLogin(){
        System.out.println("用戶1:"+user1);
        user1.login();
        System.out.println("用戶2:"+user2);
        user2.login();
    }
}

創建注解工廠類：

工廠類的內容如下：

public class AnnotationConfigApplicationContext {
    /**此Map容器用于存儲類定義對象*/
    private Map> beanDefinationFacotry=new ConcurrentHashMap<>();
    /**此Map容器用于存儲單例對象*/
    private Map singletonbeanFactory=new ConcurrentHashMap<>();
    /**有參構造方法,參數類型為指定要掃描加載的包名,此工廠可接收多個包路徑*/
    public AnnotationConfigApplicationContext(String... packageNames) {
        //遍歷掃描指定的所有包路徑
        for (String packageName : packageNames) {
            System.out.println("開始掃描包:"+packageName);
            /**掃描指定的包路徑*/
            scanPkg(packageName);
        }
        /**進行DI依賴注入*/
        dependencyInjection();
    }
}

在工廠類的構造方法中，可以接收多個包路徑，并且遍歷循環掃描每一個包路徑，掃描包的scanPkg方法如下：

/**
 * 掃描指定包,找到包中的類文件。
 * 對于標準(類上有定義注解的)類文件反射加載創建類定義對象并放入容器中
 */
private void scanPkg(final String pkg){
    //替換包名中的".",將包結構轉換為目錄結構
    String pkgDir=pkg.replaceAll(".", "/");
    //獲取目錄結構在類路徑中的位置(其中url中封裝了具體資源的路徑)
    URL url=getClass().getClassLoader().getResource(pkgDir);
    //基于這個路徑資源(url),構建一個文件對象
    File file=new File(url.getFile());
    //獲取此目錄中指定標準(以".class"結尾)的文件
    File[] fs=file.listFiles(new FileFilter() {
        @Override
        public boolean accept(File file) {
            //獲取文件名
            String fName=file.getName();
            //判斷該文件是否為目錄，如為目錄，遞歸進一步掃描其內部所有文件
            if(file.isDirectory()){
                scanPkg(pkg+"."+fName);
            }else{
                //判定文件的后綴是否為.class
                if(fName.endsWith(".class")){
                    return true;
                }
            }
            return false;
        }
    });    
    //遍歷所有符合標準的File文件
    for(File f:fs){
        //獲取文件名
        String fName=f.getName();
        //獲取去除.class之后的文件名
        fName=fName.substring(0,fName.lastIndexOf("."));
        //將名字(類名,通常為大寫開頭)的第一個字母轉換小寫(用它作為key存儲工廠中)
        String beanId=String.valueOf(fName.charAt(0)).toLowerCase()+fName.substring(1);
        //構建一個類全名(包名.類名)
        String pkgCls=pkg+"."+fName;
        try{
            //通過反射構建類對象
            Class c=Class.forName(pkgCls);
            //判定這個類上是否有MyComponent注解
            if(c.isAnnotationPresent(MyComponent.class)){
                //將類對象存儲到map容器中
                beanDefinationFacotry.put(beanId, c);
            }
        }catch(Exception e){
            throw new RuntimeException(e); 
        }
    }
}

掃描所有的包完成之后，對需要的屬性進行注入，dependencyInjection方法如下：

/**
 * 此方法用于對屬性進行依賴注入。
 * 從工廠中獲取所有的類對象，如果類中的屬性上有MyAutowired注解，
 * 那么首先從根據屬性名從工廠中獲取對象，或者根據對象類型獲取對象。
 * 最后用該對象對屬性進行注入。
 */
private void dependencyInjection(){
    //獲取容器中所有的類定義對象
    Collection> classes = beanDefinationFacotry.values();
    //遍歷每一個類對象
    for (Class cls : classes) {
        //獲取類對象的名字全稱(包名+類名)
        String clsName = cls.getName();
        //獲取類名
        clsName = clsName.substring(clsName.lastIndexOf(".")+1);
        //將類名(通常為大寫開頭)的第一個字母轉換小寫
        String beanId=String.valueOf(clsName.charAt(0)).toLowerCase()+clsName.substring(1);
        //獲取類中所有的屬性
        Field[] fields = cls.getDeclaredFields();
        //遍歷每一個屬性
        for (Field field : fields) {
            //如果這個屬性上有MyAutowired注解，進行注入操作
            if(field.isAnnotationPresent(MyAutowired.class)){
                try {
                    //獲取屬性名
                    String fieldName = field.getName();
                    System.out.println("屬性名:"+fieldName);
                    //定義為屬性注入的bean對象(此對象從容器中獲取)
                    Object fieldBean = null;
                    //首先根據屬性名從容器中取出對象，如果不為null，則賦值給fieldBean對象
                    if(beanDefinationFacotry.get(fieldName) != null){
                        fieldBean = getBean(fieldName,field.getType());
                    }else{    //否則按照屬性的類型從容器中取出對象進行注入
                        //獲取屬性的類型(包名+類名)
                        String type = field.getType().getName();
                        //截取最后的類名
                        type = type.substring(type.lastIndexOf(".")+1);
                        //將類名(通常為大寫開頭)的第一個字母轉換小寫
                        String fieldBeanId=String.valueOf(type.charAt(0)).toLowerCase()+type.substring(1);
                        System.out.println("屬性類型ID:"+fieldBeanId);
                        //根據轉換后的類型beanId，從容器中獲取對象并賦值給fieldBean對象
                        fieldBean = getBean(fieldBeanId,field.getType());
                    }
                    System.out.println("要為屬性注入的值:"+fieldBean);
                    //如果fieldBean對象不為空，則為該屬性進行注入
                    if(fieldBean != null){
                        //獲取此類定義的對象的實例對象
                        Object clsBean = getBean(beanId, cls);
                        //設置此屬性可訪問
                        field.setAccessible(true);
                        //為該屬性注入值
                        field.set(clsBean, fieldBean);
                        System.out.println("注入成功!");
                    }else{
                        System.out.println("注入失敗!");
                    }
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在dependencyInjection方法中調用了getBean方法，內容如下：

/**
 * 根據傳入的bean的id值獲取容器中的對象，類型為Object
 */
public Object getBean(String beanId){
    //根據傳入beanId獲取類對象
    Class cls = beanDefinationFacotry.get(beanId);
    //根據類對象獲取其定義的注解
    MyComponent annotation = cls.getAnnotation(MyComponent.class);
    //獲取注解的scope屬性值
    String scope = annotation.scope();
    try {
        //如果scope等于singleton,創建單例對象
        if("singleton".equals(scope) || "".equals(scope)){
            //判斷容器中是否已有該對象的實例,如果沒有,創建一個實例對象放到容器中
            if(singletonbeanFactory.get(beanId)==null){
                Object instance = cls.newInstance();
                setFieldValues(cls,instance);
                singletonbeanFactory.put(beanId,instance);
            }
            //根據beanId獲取對象并返回
            return singletonbeanFactory.get(beanId);
        }
        //如果scope等于prototype,則創建并返回多例對象
        if("prototype".equals(scope)){
            Object instance = cls.newInstance();
            setFieldValues(cls,instance);
            return instance;
        }
        //目前僅支持單例和多例兩種創建對象的方式
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    //如果遭遇異常，返回null
    return null;
}
/**
 * 此為重載方法，根據傳入的class對象在內部進行強轉，
 * 返回傳入的class對象的類型
 */
public T getBean(String beanId, Class c){
    return (T)getBean(beanId);
}

在getBean方法中從工廠容器中獲取對象，并且需要調用setFieldValues方法為對象的屬性賦值，該方法內容如下：

/**
 * 此方法用于為對象的屬性賦值
 * 內部是通過獲取成員屬性上注解的值，在轉換為類型之后，通過反射為對象賦值
 * @param cls 類定義對象
 * @param obj 要為其賦值的實例對象
 */
private void setFieldValues(Class cls,Object obj){
    //獲取類中所有的成員屬性
    Field[] fields = cls.getDeclaredFields();
    //遍歷所有屬性
    for (Field field : fields) {
        //如果此屬性有MyValue注解修飾，對其進行操作
        if(field.isAnnotationPresent(MyValue.class)){
            //獲取屬性名
            String fieldName = field.getName();
            //獲取注解中的值
            String value = field.getAnnotation(MyValue.class).value();
            //獲取屬性所定義的類型
            String type = field.getType().getName();
            //將屬性名改為以大寫字母開頭，如：id改為ID，name改為Name
            fieldName = String.valueOf(fieldName.charAt(0)).toUpperCase()+fieldName.substring(1);
            //set方法名稱，如：setId,setName...
            String setterName = "set" + fieldName;
            try {
                //根據方法名稱和參數類型獲取對應的set方法對象
                Method method = cls.getDeclaredMethod(setterName, field.getType());
                //判斷屬性類型，如類型不一致，則轉換類型后調用set方法為屬性賦值
                if("java.lang.Integer".equals(type) || "int".equals(type)){
                    int intValue = Integer.valueOf(value);
                    method.invoke(obj, intValue);
                } else if("java.lang.String".equals(type)){
                    method.invoke(obj, value);
                }
                //作為測試，僅判斷Integer和String類型，其它類型同理
            } catch (NoSuchMethodException | SecurityException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

最后是釋放工廠資源的close方法，內容如下：

/**
 * 銷毀方法，用于釋放資源
 */
public void close(){
    beanDefinationFacotry.clear();
    beanDefinationFacotry=null;
    singletonbeanFactory.clear();
    singletonbeanFactory=null;
}

工廠類創建完畢后，開始寫測試類進行測試：

測試類內容如下：

@MyComponent
public class TestSpringDi {
    /**創建AnnotationConfigApplicationContext對象*/
    AnnotationConfigApplicationContext ctx;
    /**創建UserService對象*/
    UserService userService;
    /**
     * 初始化方法
     */
    @Before
    public void init(){
        //實例化工廠類，傳入entity/service/springTest三個包路徑進行掃描
        ctx = new AnnotationConfigApplicationContext("entity","service","springTest");
        //調用工廠的getBean方法動態獲取對象
        userService = ctx.getBean("userService",UserService.class);
    }
    /**
     * 測試方法
     */
    @Test
    public void testSpringDi(){
        userService.userLogin();
    }
    /**
     * 銷毀方法
     */
    @After
    public void close(){
        ctx.close();
    }
}

以上是所有的代碼，寫完之后就可以運行程序進行測試了。運行結果如下：

從控制臺打印輸出的結果可以看出，UserService類中的兩個User屬性都已經成功注入，并調用了模擬用戶登錄的login方法，輸出的結果正是為User對象所設置的值。由于User類是單例的，因此UserService中的兩個User屬性所注入的值都是同一個對象(根據對象所映射的地址hashcode值相同可以證明這一點)，而且無參的構造方法也只執行了一次。

那么如何為多例模式的對象進行注入呢？我們在User類的注解中加上scope屬性，指定為prototype：

@MyComponent(scope="prototype")
public class User {
    ... ...
}

然后再次運行程序進行測試，結果如下：

現在可以看到，為兩個User屬性所賦的值已經是不同的對象了，無參構造方法執行了兩次。

云服務器 GPU云服務器依賴注入依賴注入方式 js依賴注入構造函數依賴注入

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/68497.html

Spring IOC知識點一網打盡！

摘要：使用的好處知乎的回答不用自己組裝，拿來就用。統一配置，便于修改。前言只有光頭才能變強回顧前面：給女朋友講解什么是代理模式包裝模式就是這么簡單啦單例模式你會幾種寫法？工廠模式理解了沒有？在刷Spring書籍的時候花了點時間去學習了單例模式和工廠模式，總的來說還是非常值得的！本來想的是刷完《Spring 實戰 (第4版)》和《精通Spring4.x 企業應用開發實戰》...

djfml 2019-08-15 17:50 評論0 收藏0
搞懂依賴注入, 用 PHP 手寫簡易 IOC 容器

摘要：依賴注入控制反轉的一種具體實現方法。接下來，我們使用依賴注入實現控制反轉，使依賴關系倒置依賴被動傳入。從單元測試的角度看，依賴注入更方便和操作，方便了測試人員寫出質量更高的測試代碼。前言好的設計會提高程序的可復用性和可維護性，也間接的提高了開發人員的生產力。今天，我們就來說一下在很多框架中都使用的依賴注入。一些概念要搞清楚什么是依賴注入如何依賴注入，首先我們要明確一些概念。 D...

antz 2019-07-01 12:42 評論0 收藏0
Spring框架之我見（三）——IOC、AOP

摘要：模塊負責的所有面向切面的功能?？偨Y的統一管理，降低了對象之間的耦合對主流的框架提供了很好的集成支持提供眾多組件，事務管理，等具有高度可開放性，開發者可以自由選擇部分或全部主要使用工廠模式和代理模式。聊完了Spring框架中最重要的兩種設計模式，我們來看一下Spring框架的模塊和結構圖。 Spring框架的結構下圖是Spring官方給出的Spring框架的結構圖。 showImg(...

khs1994 2019-08-15 13:34 評論0 收藏0
深入理解依賴注入

摘要：上面這部分代碼不變，還是通過在構造器中傳入依賴的方式初始化依賴調用這里，調用方無需了解內部對的依賴。而配置一般用于上自動掃描并注入的代碼如下這里只給出直接在依賴對象上添加注解的形式，還可以通過構造器和注入依賴，這里就不多說了。前言相信所有面試java開發的童鞋一定都被問到過是否使用過Spring，是否了解其IOC容器，為什么不直接使用工廠模式，以及究竟IOC和DI區別在于哪里這種問...

e10101 2019-08-15 18:09 評論0 收藏0
Spring之旅第一站(不得不佩服老外...)

摘要：表示少女與緊耦合在它的構造函數中自行創建了。面向切面編程往往被定義為促使軟件系統實現關注點的分離一項技術系統由許多不同的組件組成，每個組件各負責一特定的功能。我們可以把切面想象為覆蓋在很多組件之上的一個外殼。第1章 Spring之旅說明 1、本文抄寫了《Spring 實戰》重點內容，參考了GitHub上的代碼 2、每個人的學習方式不一樣，但目的是一樣的，活學活用。最近一直在聽《我...

thekingisalwaysluc 2019-08-15 14:15 評論0 收藏0