[手写spring](3)初始化singletonObjects，实现依赖注入

超、凢脫俗 2023-09-28 12:52 13阅读 0赞

**目录**

目标

自定义注解

创建singletonObjects

实现singletonObjects的初始化

实现createBean方法

解决singletonObjects的依赖注入

实现getBean方法

测试

总结

--------------------

## 目标 ##

在这篇文章中会实现几个相对复杂的功能，包括依赖注入，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");
        }
    }

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

![1691accfc7c34f2eb1652fb6a7516195.png][]

> 下面是在测试类中的内容

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

> 输出如下

![ec67700ff77c4c83ba81b2648e16c9b7.png][]

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

--------------------

## 总结 ##

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

--------------------

**手写spring系列**

[\[手写spring\](1)构建框架，实现包扫描][spring_1]

[\[手写spring\](2)初始化BeanDefinitionMap][spring_2_BeanDefinitionMap]

[\[手写spring\](3)初始化singletonObjects，实现依赖注入][spring_3_singletonObjects]

[\[手写spring\](4)实现后置处理器][spring_4]

[\[手写spring\](5)实现AOP机制（完结）][spring_5_AOP]

[1691accfc7c34f2eb1652fb6a7516195.png]: https://img-blog.csdnimg.cn/1691accfc7c34f2eb1652fb6a7516195.png
[ec67700ff77c4c83ba81b2648e16c9b7.png]: https://img-blog.csdnimg.cn/ec67700ff77c4c83ba81b2648e16c9b7.png
[spring_1]: https://blog.csdn.net/m0_51545690/article/details/125537490
[spring_2_BeanDefinitionMap]: https://blog.csdn.net/m0_51545690/article/details/125538391
[spring_3_singletonObjects]: https://blog.csdn.net/m0_51545690/article/details/125542853
[spring_4]: https://blog.csdn.net/m0_51545690/article/details/125544613
[spring_5_AOP]: https://blog.csdn.net/m0_51545690/article/details/125549292