手动模拟实现Spring IOC功能（基于javaConfig风格）

　　以下文中spring特指spring frameWork项目，不含其它：如spring cloud等。

　　作为刚开始研究spring源码的小白，对于spring两大核心功能之一的IOC，虽说大致了解了Bean的注册与实例化过程、PostProcessors对于bean的实例化的干预等，还是觉得自己要手动实践下IOC功能，算是考验下自己是否对spring源码有了初步的入门。此次模拟基于annotation风格，也比较符合现在spring的开发主流趋势。由于是手动实现，当然不能通过springboot构建项目，采用idea或eclipse创建一个普通的web工程吧。按照开发的先后顺序吧。

　　自定义的几个注解

　　熟悉基于配置的风格的童鞋都知道，spring里面最最常用的注解@ComponentScan，@Component和@Autowired。稍稍说下这三个注解的作用，@ComponentScan：对于指定的目录下的Bean的扫描。@Component：描述一个普通的pojo，告知spring上下文这个pojo需要被spring容器所管理，也就是spring 中的bean。@Autowired：Bean中属性的自动注入，默认注入是按照bytype。那么，照葫芦画瓢，对应的定义了下面三个注解

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAutowired {
    String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponentScan {
    String value();
}

　　注意，每个自定义注解至少应该添加注解@Retention，并且指定value是runtime。@Retention是用来修饰注解的注解，也就是元注解。RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在。

　　定义几个pojo

　　一个是配置类MyConfigure，用于指定扫描路径，功能单一。加上自定义的注解@MyComponentScan。指定扫描com.entity路径下的类。

package com.entity;
import com.annotate.MyComponentScan;

@MyComponentScan("com.entity")
public class MyConfigure {

}

　　两个简单的实体类Order和User，加上自定义注解@MyComponent。其中Order中有个成员属性User，加入注解@MyAutowired。

package com.entity;

import com.annotate.MyAutowired;
import com.annotate.MyComponent;

@MyComponent("myComponent")
public class Order {
    @MyAutowired
    private User user;

    public void print(){
        System.out.println("This is order");
    }

    public void printUser(){
        this.user.printMessage();
    }
}

package com.entity;

import com.annotate.MyComponent;

@MyComponent("myComponent")
public class User {
    public void print(){
        System.out.println("This is user");
    }

    public void printMessage(){
        System.out.println("This is user from order");
    }
}

　　spring上下文的模拟

　　MySpringApplicationContext实现的spring上下文，主要包含了根据路径扫描的注册Bean方法和getBean过程，也包含一个主要的成员属性map，用于存放上下文中被注册并实例化的Bean。

package com.myspring;

import com.annotate.MyAutowired;
import com.annotate.MyComponent;
import com.annotate.MyComponentScan;

import java.io.File;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MySpringApplicationContext {
    /**
     * 存放bean的map(模仿spring beanfactory 中的map)
     */
    private HashMap<String,Object> beanFactoryMap;

    public MySpringApplicationContext(Class clazz){
        beanFactoryMap = new HashMap<String, Object>();
        this.packageScan(clazz);
    }


    public void packageScan(Class configureClazz){
        //获取扫描路径
        MyComponentScan myComponentScan = (MyComponentScan) configureClazz.getAnnotation(MyComponentScan.class);
        if(myComponentScan == null){
            return;
        }
        /**
         * 获取待扫描的目录
         */
        String packageName = myComponentScan.value();
        String rootPath = this.getClass().getResource("/").getPath();
        String packagePath = packageName.replaceAll("\\.","/");
        /**
         * 获取扫描目录的绝对地址
         */
        String classFilePath = rootPath + packagePath;
        File file = new File(classFilePath);
        String[] files = file.list();
        if(files != null && files.length>0){
            for(String subFile:files){
                try {
                    String beanName = subFile.split("\\.")[0];
                    Class clazz = Class.forName(packageName +"."+ beanName);
                    if(clazz.isAnnotationPresent(MyComponent.class)){
                        Object object = clazz.newInstance();
                        beanFactoryMap.put(beanName.toLowerCase(),object);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        //处理注入的问题（模拟@Autowired）
        if(!beanFactoryMap.isEmpty()){
            Iterator iterator = beanFactoryMap.entrySet().iterator();
            while (iterator.hasNext()){
                try {
                    Map.Entry entry = (Map.Entry) iterator.next();
                    Class clazz = entry.getValue().getClass();
                    Field[] fields = clazz.getDeclaredFields();
                    if(fields != null && fields.length > 0){
                        for(Field field:fields){
                            field.setAccessible(true);
                            MyAutowired myAutowired = field.getAnnotation(MyAutowired.class);
                            if(myAutowired != null){
                                field.set(entry.getValue(),beanFactoryMap.get(field.getName()));
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public Object getBean(String beanName){
        return this.beanFactoryMap.get(beanName);
    }

}

　　测试

　　主要测试内容是Bean的成功注册并实例化，Bean的成功注入。

package com.test;

import com.entity.User;
import com.myspring.MySpringApplicationContext;
import com.entity.MyConfigure;
import com.entity.Order;
public class Test {
    public static void main(String[] args) {
        MySpringApplicationContext mySpringApplicationContext = new MySpringApplicationContext(MyConfigure.class);
        User user = (User) mySpringApplicationContext.getBean("user");
        user.print();
        Order order = (Order) mySpringApplicationContext.getBean("order");
        order.print();
        /**
         * 用于验证Order中是否成功注入User对象
         */
        order.printUser();
    }
}

　　结果输出

This is user
This is order
This is user from order

　　以上是手动实现spring IOC功能的全过程，当然这只是spring机制的皮毛的皮毛，希望给有欲望去了解，但还未实施了解spring源码的童鞋以帮助，抛砖引玉。实力有限，欢迎各位专家同仁批评指正。