目标

        在这篇文章中会实现几个相对复杂的功能，包括依赖注入，getBean方法，构建单例对象池。这篇文章内容应该会比较多，难度也较大，但咬牙拿下，对理解spring又会上一个新台阶，下面就直接开始吧

---

自定义注解

        由于我们要实现依赖注入，所以肯定要提供相应的注解，这里我选择实现@Resource

@Target(value = {ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Resource {
    String value() default "";
}

---

创建singletonObjects

        这个容器用来存储单例对象，k-v的形式

    private ConcurrentHashMap<String, Object> singletonObjects;

    //代码块初始化集合
    {
        singletonObjects = new ConcurrentHashMap<>();
    }

---

实现singletonObjects的初始化

        我们创建一个initSingletonObjects的方法，这个方法根据beanDefinitionMap实现singletonObjects的初始化。（提醒：这个方法要放入到构造器中，在初始化beanDefinitionMap后进行调用）

    protected void initSingletonObjects() {
        Set<Map.Entry<String, BeanDefinition>> entries = this.beanDefinitionMap.entrySet();
        //遍历beanDefinitionMap所有信息
        for (Map.Entry<String, BeanDefinition> entry : entries) {
            //如果是单例模式，创建对象放入singletonObjects,此时没有解决依赖问题
            if (entry.getValue().getType().equals("singleton")) {
                Object bean = null;
                try {
                    bean = (entry.getValue().getClazz().newInstance());
                } catch (InstantiationException | IllegalAccessException e) {
                    e.printStackTrace();
                }
                String name = entry.getKey();
                singletonObjects.put(name, bean);
            }
        }
    }

---

实现createBean方法

        故名思意，这个方法用于创建bean，传入一个class对象，返回一个Object

    protected Object createBean(Class<?> classes, String beanName) {
        Object o = null;
        try {
            //创建实例对象
            o = classes.newInstance();
            //对每个字段进行判断，查看是否需要依赖注入
            for (Field field : classes.getDeclaredFields()) {
                //判断是否具有@Resource注解
                if (field.isAnnotationPresent(Resource.class)) {
                    //得到@Resource注解
                    Resource resource = field.getAnnotation(Resource.class);
                    //得到配置的值，为空则使用属性名作为name
                    String name = resource.value();
                    if ("".equals(name)) {
                        name = field.getName();
                    }
                    //开放字段访问权限，用于对属性值进行注入
                    field.setAccessible(true);
                    //判断beanDefinitionMap中是否存在该name
                    if (beanDefinitionMap.containsKey(name)) {
                        //得到该beanDefinition
                        BeanDefinition beanDefinition = beanDefinitionMap.get(name);
                        Object o1 = null;
                        //判断是不是单例模式
                        if (beanDefinition.getType().equals("singleton")) {
                            //是单例模式直接获取
                            o1 = singletonObjects.get(name);
                        } else {
                            //不是单例模式需要进行创建
                            o1 = createBean(beanDefinition.getClazz(), beanName);
                        }
                        //注入属性值
                        field.set(o, o1);
                    } else {
                        throw new RuntimeException(name + "在容器中不存在，无法注入");
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return o;
    }

         我们上面这个方法传入了2个参数，其中一个是beanName，现在没有用到，但是后面需要，这里先不解释原因。

        上面代码的就表示我们通过class创建对象，并且对属性进行遍历，看是否需要进行注入，并且还要考虑要注入的属性是否为单例的，是单例那么就直接从singletonObjects获取，如果不是，那么就实例化一个。

        我们在这里实现依赖注入是通过byName的方式实现的，通过获取@Resource注解的value，如果没有填value，那么就使用属性名作为name。

---

解决singletonObjects的依赖注入

        在上面的初始化singletonObjects的过程中，我们并没有考虑依赖注入的问题，现在我们来实现依赖注入。我们对singletonObjects中的每一个对象的属性进行遍历，检查是否需要进行注入。

        //解决依赖问题
        for (Map.Entry<String, Object> entry : this.singletonObjects.entrySet()) {
            Object o = entry.getValue();
            String beanName = entry.getKey();
            //对每一个字段进行遍历，看是否存在@Resource注解
            for (Field field : o.getClass().getDeclaredFields()) {
                if (field.isAnnotationPresent(Resource.class)) {
                    Resource resource = field.getAnnotation(Resource.class);
                    //得到配置的值，为空则使用属性名作为name
                    String name = resource.value();
                    if ("".equals(name)) {
                        name = field.getName();
                    }
                    //开放字段访问权限，用于对属性值进行注入
                    field.setAccessible(true);
                    if (beanDefinitionMap.containsKey(name)) {
                        //得到该beanDefinition
                        BeanDefinition beanDefinition = beanDefinitionMap.get(name);
                        Object o1 = null;
                        //判断是不是单例模式
                        if (beanDefinition.getType().equals("singleton")) {
                            //是单例模式直接获取
                            o1 = singletonObjects.get(name);
                        } else {
                            //不是单例模式需要进行创建
                            o1 = createBean(beanDefinition.getClazz(), name);
                        }
                        //注入属性值
                        try {
                            field.set(o, o1);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    } else {
                        throw new RuntimeException(name + "在容器中不存在，无法注入");
                    }
                }
            }
        }

---

实现getBean方法

        我们通过getBean，通过一个name可以获取到对象。这里有3种情况，如果该对象是单例的，那么直接从singletonObjects中进行返回。如果是多例的，那么就创建一个。如果该name在beanDefinitionMap中不存在，那么就报错。

    public <T> T getBean(String name, Class<T> tClass) {
        if (beanDefinitionMap.containsKey(name)) {
            //通过name得到beanDefinition
            BeanDefinition beanDefinition = beanDefinitionMap.get(name);
            //判断是不是单例模式
            if (beanDefinition.getType().equals("singleton")) {
                return (T) singletonObjects.get(name);
            } else {
                return (T) createBean(beanDefinition.getClazz(), name);
            }
        } else {
            throw new NullPointerException("没有名称为：" + name + "的bean");
        }
    }

---

测试

        在这里，我们需要测试单例模式和多例模式下的getBean获取到的对象是否为同一个，还要测试依赖注入是否成功。我们构造一些bean用于测试。

@Component
@Scope(type = "prototype")
public class MemberDao {
}

@Component("myUserDao")
public class UserDao {

    public void show(){
        System.out.println("我是userDao");
    }
}

@Component
public class UserService {

    @Resource("myUserDao")
    private UserDao userDao;

    public void show(){
        userDao.show();
        System.out.println("我是userService");
    }
}

@Component
public class UserController {

    @Resource
    private UserService userService;

    public void show(){
        userService.show();
        System.out.println("我是userController");
    }
}

        上面几个类在项目中的位置如下

         下面是在测试类中的内容

public class MySpringTest {

    public static void main(String[] args) {
        ApplicationContext ioc = new ApplicationContext(ComponentScanPathConfig.class);
        //测试依赖注入
        UserController userController1 = ioc.getBean("userController", UserController.class);
        userController1.show();
        System.out.println("----------------------");

        //测试单例多例模式的getBean
        UserController userController2 = ioc.getBean("userController", UserController.class);
        System.out.println("单例模式userController1 userController2相等？" + (userController1 == userController2));
        System.out.println("----------------------");

        MemberDao memberDao1 = ioc.getBean("memberDao", MemberDao.class);
        MemberDao memberDao2 = ioc.getBean("memberDao", MemberDao.class);
        System.out.println("多例模式memberDao1 memberDao2相等？" + (memberDao1 == memberDao2));
    }
}

         输出如下

         可以发现，代码没有问题，测试成功

---

总结

        到现在，我们已经将自己的spring的框架基本搭好了，我们在这里实现依赖注入的方式和原本的spring不一样，我是尽量简化的，但是我们依赖注入的功能实现是没有任何问题的，原生实在有点麻烦，就不考虑了。在下一篇文章中将会实现bean的后置处理器，后置处理器是AOP的关键！！！后面的文章基本都是在现在的框架上进行功能的增添了。