摘要：如感興趣，可移步手寫之基于動態(tài)創(chuàng)建對象手寫之基于注解動態(tài)創(chuàng)建對象今天將詳細(xì)介紹如何手寫依賴注入，在運(yùn)行過程中如何動態(tài)地為對象的屬性賦值。完成后在中會有相關(guān)的包出現(xiàn)進(jìn)行注入前需要創(chuàng)建工廠，在運(yùn)行時(shí)從工廠中取出對象為屬性賦值。

前兩篇文章介紹了關(guān)于手寫Spring IOC控制反轉(zhuǎn)，由Spring工廠在運(yùn)行過程中動態(tài)地創(chuàng)建對象的兩種方式。如感興趣，可移步：

手寫Spring之IOC基于xml動態(tài)創(chuàng)建對象

手寫Spring之IOC基于注解動態(tài)創(chuàng)建對象

今天將詳細(xì)介紹如何手寫Spring DI依賴注入，在運(yùn)行過程中如何動態(tài)地為對象的屬性賦值。

首先還是創(chuàng)建項(xiàng)目，用于本次測試需要使用到j(luò)unit，因此創(chuàng)建的是Maven項(xiàng)目，方便添加依賴jar包，JDK環(huán)境還是1.7：

接下來在pom.xml文件中添加junit的依賴坐標(biāo)：

  junit
  junit
  4.10
  test

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

完成后在Maven Dependencies中會有相關(guān)的jar包出現(xiàn)：

進(jìn)行DI注入前需要創(chuàng)建工廠，在運(yùn)行時(shí)從工廠中取出對象為屬性賦值。因此先做一些準(zhǔn)備工作，創(chuàng)建幾個(gè)要用到的注解：

MyComponent注解內(nèi)容如下：

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 屬性表示所定義的注解何時(shí)有效,
 * RetentionPolicy.RUNTIME表示在運(yùn)行時(shí)有效*/
@Retention(RetentionPolicy.RUNTIME)
/**@interface 表示注解類型*/
public @interface MyComponent {
    /**為此注解定義scope屬性*/
    public String scope() default "";
}

MyAutowired注解內(nèi)容如下：

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注解內(nèi)容如下：

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();
}

接下來創(chuàng)建實(shí)體類：

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

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

然后創(chuàng)建UserService類，在Service類中使用依賴注入U(xiǎn)ser：

UserService內(nèi)容如下：

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();
    }
}

創(chuàng)建注解工廠類：

工廠類的內(nèi)容如下：

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

在工廠類的構(gòu)造方法中，可以接收多個(gè)包路徑，并且遍歷循環(huán)掃描每一個(gè)包路徑，掃描包的scanPkg方法如下：

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

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

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

在dependencyInjection方法中調(diào)用了getBean方法，內(nèi)容如下：

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

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

/**
 * 此方法用于為對象的屬性賦值
 * 內(nèi)部是通過獲取成員屬性上注解的值，在轉(zhuǎn)換為類型之后，通過反射為對象賦值
 * @param cls 類定義對象
 * @param obj 要為其賦值的實(shí)例對象
 */
private void setFieldValues(Class cls,Object obj){
    //獲取類中所有的成員屬性
    Field[] fields = cls.getDeclaredFields();
    //遍歷所有屬性
    for (Field field : fields) {
        //如果此屬性有MyValue注解修飾，對其進(jìn)行操作
        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 {
                //根據(jù)方法名稱和參數(shù)類型獲取對應(yīng)的set方法對象
                Method method = cls.getDeclaredMethod(setterName, field.getType());
                //判斷屬性類型，如類型不一致，則轉(zhuǎn)換類型后調(diào)用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方法，內(nèi)容如下：

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

工廠類創(chuàng)建完畢后，開始寫測試類進(jìn)行測試：

測試類內(nèi)容如下：

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

以上是所有的代碼，寫完之后就可以運(yùn)行程序進(jìn)行測試了。運(yùn)行結(jié)果如下：

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

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

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

然后再次運(yùn)行程序進(jìn)行測試，結(jié)果如下：

現(xiàn)在可以看到，為兩個(gè)User屬性所賦的值已經(jīng)是不同的對象了，無參構(gòu)造方法執(zhí)行了兩次。