资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/手写Spring之DI依赖注入

手写Spring之DI依赖注入

Cruise_Chan / 1900人阅读

摘要：如感兴趣，可移步手写之基于动态创建对象手写之基于注解动态创建对象今天将详细介绍如何手写依赖注入，在运行过程中如何动态地为对象的属性赋值。完成后在中会有相关的包出现进行注入前需要创建工厂，在运行时从工厂中取出对象为属性赋值。

前两篇文章介绍了关于手写Spring IOC控制反转，由Spring工厂在运行过程中动态地创建对象的两种方式。如感兴趣，可移步：

手写Spring之IOC基于xml动态创建对象

手写Spring之IOC基于注解动态创建对象

今天将详细介绍如何手写Spring DI依赖注入，在运行过程中如何动态地为对象的属性赋值。

首先还是创建项目，用于本次测试需要使用到junit，因此创建的是Maven项目，方便添加依赖jar包，JDK环境还是1.7：

接下来在pom.xml文件中添加junit的依赖坐标：

</>复制代码 
  2.   junit
  3.   junit
  4.   4.10
  5.   test

第一次添加时，若本地仓库中没有此版本的jar包，Maven会根据配置的镜像联网下载，默认是去中心仓库下载，中心仓库的服务器在国外，下载速度较慢，建议修改配置文件连接阿里云的Maven镜像仓库下载，速度较快，如何配置在此不多赘述。你也可以根据自己本地仓库已有的junit版本 对依赖坐标的版本进行修改，这样就可以直接使用本地仓库的jar包，不用耗时连外网去下载了。

完成后在Maven Dependencies中会有相关的jar包出现：

进行DI注入前需要创建工厂，在运行时从工厂中取出对象为属性赋值。因此先做一些准备工作，创建几个要用到的注解：

MyComponent注解内容如下：

</>复制代码 
  1. package annotation;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. /**@Target 属性用于注明此注解用在什么位置,
  7.  * ElementType.TYPE表示可用在类、接口、枚举上等*/
  8. @Target(ElementType.TYPE)
  9. /**@Retention 属性表示所定义的注解何时有效,
  10.  * RetentionPolicy.RUNTIME表示在运行时有效*/
  11. @Retention(RetentionPolicy.RUNTIME)
  12. /**@interface 表示注解类型*/
  13. public @interface MyComponent {
  14.     /**为此注解定义scope属性*/
  15.     public String scope() default "";
  16. }

MyAutowired注解内容如下：

</>复制代码 
  1. package annotation;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.FIELD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface MyAutowired {
  9. }

MyValue注解内容如下：

</>复制代码 
  1. package annotation;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.FIELD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface MyValue {
  9.     /**定义value属性*/
  10.     public String value();
  11. }

接下来创建实体类：

User实体类内容如下，实体类中的属性值暂用注解方式写死作为测试(实际中并不会这么用)，此实体类暂时为单例类(不注明scope属性默认为单例模式)：

</>复制代码 
  1. @MyComponent
  2. public class User {
  3.     @MyValue("1")
  4.     private Integer id;
  5.     @MyValue("zhangsan")
  6.     private String name;
  7.     @MyValue("zhangsan")
  8.     private String password;
  9.     
  10.     public User() {
  11.         System.out.println("无参构造方法执行");
  12.     }
  13.     
  14.     public void login(){
  15.         System.out.println("用户登录：id=" + id + ", name=" + name + ", password=" + password);
  16.     }
  17.     
  18.     //setters和getters...
  19. }

然后创建UserService类，在Service类中使用依赖注入User：

UserService内容如下：

</>复制代码 
  1. package service;
  2. import annotation.MyAutowired;
  3. import annotation.MyComponent;
  4. import entity.User;
  5. @MyComponent
  6. public class UserService {
  7.     @MyAutowired
  8.     User user1;
  9.     
  10.     @MyAutowired
  11.     User user2;
  12.     
  13.     public void userLogin(){
  14.         System.out.println("用户1:"+user1);
  15.         user1.login();
  16.         System.out.println("用户2:"+user2);
  17.         user2.login();
  18.     }
  19. }

创建注解工厂类：

工厂类的内容如下：

</>复制代码 
  1. public class AnnotationConfigApplicationContext {
  2.     /**此Map容器用于存储类定义对象*/
  3.     private Map> beanDefinationFacotry=new ConcurrentHashMap<>();
  4.     /**此Map容器用于存储单例对象*/
  5.     private Map singletonbeanFactory=new ConcurrentHashMap<>();
  6.     /**有参构造方法,参数类型为指定要扫描加载的包名,此工厂可接收多个包路径*/
  7.     public AnnotationConfigApplicationContext(String... packageNames) {
  8.         //遍历扫描指定的所有包路径
  9.         for (String packageName : packageNames) {
  10.             System.out.println("开始扫描包:"+packageName);
  11.             /**扫描指定的包路径*/
  12.             scanPkg(packageName);
  13.         }
  14.         /**进行DI依赖注入*/
  15.         dependencyInjection();
  16.     }
  17. }

在工厂类的构造方法中，可以接收多个包路径，并且遍历循环扫描每一个包路径，扫描包的scanPkg方法如下：

</>复制代码 
  1. /**
  2.  * 扫描指定包,找到包中的类文件。
  3.  * 对于标准(类上有定义注解的)类文件反射加载创建类定义对象并放入容器中
  4.  */
  5. private void scanPkg(final String pkg){
  6.     //替换包名中的".",将包结构转换为目录结构
  7.     String pkgDir=pkg.replaceAll(".", "/");
  8.     //获取目录结构在类路径中的位置(其中url中封装了具体资源的路径)
  9.     URL url=getClass().getClassLoader().getResource(pkgDir);
  10.     //基于这个路径资源(url),构建一个文件对象
  11.     File file=new File(url.getFile());
  12.     //获取此目录中指定标准(以".class"结尾)的文件
  13.     File[] fs=file.listFiles(new FileFilter() {
  14.         @Override
  15.         public boolean accept(File file) {
  16.             //获取文件名
  17.             String fName=file.getName();
  18.             //判断该文件是否为目录，如为目录，递归进一步扫描其内部所有文件
  19.             if(file.isDirectory()){
  20.                 scanPkg(pkg+"."+fName);
  21.             }else{
  22.                 //判定文件的后缀是否为.class
  23.                 if(fName.endsWith(".class")){
  24.                     return true;
  25.                 }
  26.             }
  27.             return false;
  28.         }
  29.     });    
  30.     //遍历所有符合标准的File文件
  31.     for(File f:fs){
  32.         //获取文件名
  33.         String fName=f.getName();
  34.         //获取去除.class之后的文件名
  35.         fName=fName.substring(0,fName.lastIndexOf("."));
  36.         //将名字(类名,通常为大写开头)的第一个字母转换小写(用它作为key存储工厂中)
  37.         String beanId=String.valueOf(fName.charAt(0)).toLowerCase()+fName.substring(1);
  38.         //构建一个类全名(包名.类名)
  39.         String pkgCls=pkg+"."+fName;
  40.         try{
  41.             //通过反射构建类对象
  42.             Class c=Class.forName(pkgCls);
  43.             //判定这个类上是否有MyComponent注解
  44.             if(c.isAnnotationPresent(MyComponent.class)){
  45.                 //将类对象存储到map容器中
  46.                 beanDefinationFacotry.put(beanId, c);
  47.             }
  48.         }catch(Exception e){
  49.             throw new RuntimeException(e); 
  50.         }
  51.     }
  52. }

扫描所有的包完成之后，对需要的属性进行注入，dependencyInjection方法如下：

</>复制代码 
  1. /**
  2.  * 此方法用于对属性进行依赖注入。
  3.  * 从工厂中获取所有的类对象，如果类中的属性上有MyAutowired注解，
  4.  * 那么首先从根据属性名从工厂中获取对象，或者根据对象类型获取对象。
  5.  * 最后用该对象对属性进行注入。
  6.  */
  7. private void dependencyInjection(){
  8.     //获取容器中所有的类定义对象
  9.     Collection> classes = beanDefinationFacotry.values();
  10.     //遍历每一个类对象
  11.     for (Class cls : classes) {
  12.         //获取类对象的名字全称(包名+类名)
  13.         String clsName = cls.getName();
  14.         //获取类名
  15.         clsName = clsName.substring(clsName.lastIndexOf(".")+1);
  16.         //将类名(通常为大写开头)的第一个字母转换小写
  17.         String beanId=String.valueOf(clsName.charAt(0)).toLowerCase()+clsName.substring(1);
  18.         //获取类中所有的属性
  19.         Field[] fields = cls.getDeclaredFields();
  20.         //遍历每一个属性
  21.         for (Field field : fields) {
  22.             //如果这个属性上有MyAutowired注解，进行注入操作
  23.             if(field.isAnnotationPresent(MyAutowired.class)){
  24.                 try {
  25.                     //获取属性名
  26.                     String fieldName = field.getName();
  27.                     System.out.println("属性名:"+fieldName);
  28.                     //定义为属性注入的bean对象(此对象从容器中获取)
  29.                     Object fieldBean = null;
  30.                     //首先根据属性名从容器中取出对象，如果不为null，则赋值给fieldBean对象
  31.                     if(beanDefinationFacotry.get(fieldName) != null){
  32.                         fieldBean = getBean(fieldName,field.getType());
  33.                     }else{    //否则按照属性的类型从容器中取出对象进行注入
  34.                         //获取属性的类型(包名+类名)
  35.                         String type = field.getType().getName();
  36.                         //截取最后的类名
  37.                         type = type.substring(type.lastIndexOf(".")+1);
  38.                         //将类名(通常为大写开头)的第一个字母转换小写
  39.                         String fieldBeanId=String.valueOf(type.charAt(0)).toLowerCase()+type.substring(1);
  40.                         System.out.println("属性类型ID:"+fieldBeanId);
  41.                         //根据转换后的类型beanId，从容器中获取对象并赋值给fieldBean对象
  42.                         fieldBean = getBean(fieldBeanId,field.getType());
  43.                     }
  44.                     System.out.println("要为属性注入的值:"+fieldBean);
  45.                     //如果fieldBean对象不为空，则为该属性进行注入
  46.                     if(fieldBean != null){
  47.                         //获取此类定义的对象的实例对象
  48.                         Object clsBean = getBean(beanId, cls);
  49.                         //设置此属性可访问
  50.                         field.setAccessible(true);
  51.                         //为该属性注入值
  52.                         field.set(clsBean, fieldBean);
  53.                         System.out.println("注入成功!");
  54.                     }else{
  55.                         System.out.println("注入失败!");
  56.                     }
  57.                 } catch (IllegalArgumentException | IllegalAccessException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.         }
  62.     }
  63. }

在dependencyInjection方法中调用了getBean方法，内容如下：

</>复制代码 
  1. /**
  2.  * 根据传入的bean的id值获取容器中的对象，类型为Object
  3.  */
  4. public Object getBean(String beanId){
  5.     //根据传入beanId获取类对象
  6.     Class cls = beanDefinationFacotry.get(beanId);
  7.     //根据类对象获取其定义的注解
  8.     MyComponent annotation = cls.getAnnotation(MyComponent.class);
  9.     //获取注解的scope属性值
  10.     String scope = annotation.scope();
  11.     try {
  12.         //如果scope等于singleton,创建单例对象
  13.         if("singleton".equals(scope) || "".equals(scope)){
  14.             //判断容器中是否已有该对象的实例,如果没有,创建一个实例对象放到容器中
  15.             if(singletonbeanFactory.get(beanId)==null){
  16.                 Object instance = cls.newInstance();
  17.                 setFieldValues(cls,instance);
  18.                 singletonbeanFactory.put(beanId,instance);
  19.             }
  20.             //根据beanId获取对象并返回
  21.             return singletonbeanFactory.get(beanId);
  22.         }
  23.         //如果scope等于prototype,则创建并返回多例对象
  24.         if("prototype".equals(scope)){
  25.             Object instance = cls.newInstance();
  26.             setFieldValues(cls,instance);
  27.             return instance;
  28.         }
  29.         //目前仅支持单例和多例两种创建对象的方式
  30.     } catch (InstantiationException e) {
  31.         e.printStackTrace();
  32.     } catch (IllegalAccessException e) {
  33.         e.printStackTrace();
  34.     }
  35.     //如果遭遇异常，返回null
  36.     return null;
  37. }
  38. /**
  39.  * 此为重载方法，根据传入的class对象在内部进行强转，
  40.  * 返回传入的class对象的类型
  41.  */
  42. public T getBean(String beanId, Class c){
  43.     return (T)getBean(beanId);
  44. }

在getBean方法中从工厂容器中获取对象，并且需要调用setFieldValues方法为对象的属性赋值，该方法内容如下：

</>复制代码 
  1. /**
  2.  * 此方法用于为对象的属性赋值
  3.  * 内部是通过获取成员属性上注解的值，在转换为类型之后，通过反射为对象赋值
  4.  * @param cls 类定义对象
  5.  * @param obj 要为其赋值的实例对象
  6.  */
  7. private void setFieldValues(Class cls,Object obj){
  8.     //获取类中所有的成员属性
  9.     Field[] fields = cls.getDeclaredFields();
  10.     //遍历所有属性
  11.     for (Field field : fields) {
  12.         //如果此属性有MyValue注解修饰，对其进行操作
  13.         if(field.isAnnotationPresent(MyValue.class)){
  14.             //获取属性名
  15.             String fieldName = field.getName();
  16.             //获取注解中的值
  17.             String value = field.getAnnotation(MyValue.class).value();
  18.             //获取属性所定义的类型
  19.             String type = field.getType().getName();
  20.             //将属性名改为以大写字母开头，如：id改为ID，name改为Name
  21.             fieldName = String.valueOf(fieldName.charAt(0)).toUpperCase()+fieldName.substring(1);
  22.             //set方法名称，如：setId,setName...
  23.             String setterName = "set" + fieldName;
  24.             try {
  25.                 //根据方法名称和参数类型获取对应的set方法对象
  26.                 Method method = cls.getDeclaredMethod(setterName, field.getType());
  27.                 //判断属性类型，如类型不一致，则转换类型后调用set方法为属性赋值
  28.                 if("java.lang.Integer".equals(type) || "int".equals(type)){
  29.                     int intValue = Integer.valueOf(value);
  30.                     method.invoke(obj, intValue);
  31.                 } else if("java.lang.String".equals(type)){
  32.                     method.invoke(obj, value);
  33.                 }
  34.                 //作为测试，仅判断Integer和String类型，其它类型同理
  35.             } catch (NoSuchMethodException | SecurityException e) {
  36.                 e.printStackTrace();
  37.             } catch (IllegalAccessException e) {
  38.                 e.printStackTrace();
  39.             } catch (IllegalArgumentException e) {
  40.                 e.printStackTrace();
  41.             } catch (InvocationTargetException e) {
  42.                 e.printStackTrace();
  43.             }
  44.         }
  45.     }
  46. }

最后是释放工厂资源的close方法，内容如下：

</>复制代码 
  1. /**
  2.  * 销毁方法，用于释放资源
  3.  */
  4. public void close(){
  5.     beanDefinationFacotry.clear();
  6.     beanDefinationFacotry=null;
  7.     singletonbeanFactory.clear();
  8.     singletonbeanFactory=null;
  9. }

工厂类创建完毕后，开始写测试类进行测试：

测试类内容如下：

</>复制代码 
  1. @MyComponent
  2. public class TestSpringDi {
  3.     /**创建AnnotationConfigApplicationContext对象*/
  4.     AnnotationConfigApplicationContext ctx;
  5.     /**创建UserService对象*/
  6.     UserService userService;
  7.     /**
  8.      * 初始化方法
  9.      */
  10.     @Before
  11.     public void init(){
  12.         //实例化工厂类，传入entity/service/springTest三个包路径进行扫描
  13.         ctx = new AnnotationConfigApplicationContext("entity","service","springTest");
  14.         //调用工厂的getBean方法动态获取对象
  15.         userService = ctx.getBean("userService",UserService.class);
  16.     }
  17.     /**
  18.      * 测试方法
  19.      */
  20.     @Test
  21.     public void testSpringDi(){
  22.         userService.userLogin();
  23.     }
  24.     /**
  25.      * 销毁方法
  26.      */
  27.     @After
  28.     public void close(){
  29.         ctx.close();
  30.     }
  31. }

以上是所有的代码，写完之后就可以运行程序进行测试了。运行结果如下：

从控制台打印输出的结果可以看出，UserService类中的两个User属性都已经成功注入，并调用了模拟用户登录的login方法，输出的结果正是为User对象所设置的值。由于User类是单例的，因此UserService中的两个User属性所注入的值都是同一个对象(根据对象所映射的地址hashcode值相同可以证明这一点)，而且无参的构造方法也只执行了一次。

那么如何为多例模式的对象进行注入呢？我们在User类的注解中加上scope属性，指定为prototype：

</>复制代码 
  1. @MyComponent(scope="prototype")
  2. public class User {
  3.     ... ...
  4. }

然后再次运行程序进行测试，结果如下：

现在可以看到，为两个User属性所赋的值已经是不同的对象了，无参构造方法执行了两次。

云服务器 GPU云服务器 依赖注入 依赖注入方式 js依赖注入 构造函数依赖注入

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/68497.html

相关文章

  • Spring IOC知识点一网打尽！

    摘要：使用的好处知乎的回答不用自己组装，拿来就用。统一配置，便于修改。 前言 只有光头才能变强 回顾前面： 给女朋友讲解什么是代理模式 包装模式就是这么简单啦 单例模式你会几种写法？ 工厂模式理解了没有？ 在刷Spring书籍的时候花了点时间去学习了单例模式和工厂模式，总的来说还是非常值得的！ 本来想的是刷完《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》...

    djfml 评论0 收藏0

  • 搞懂依赖注入, 用 PHP 手写简易 IOC 容器

    摘要：依赖注入控制反转的一种具体实现方法。接下来，我们使用依赖注入实现控制反转，使依赖关系倒置依赖被动传入。从单元测试的角度看，依赖注入更方便和操作，方便了测试人员写出质量更高的测试代码。 前言 好的设计会提高程序的可复用性和可维护性，也间接的提高了开发人员的生产力。今天，我们就来说一下在很多框架中都使用的依赖注入。 一些概念 要搞清楚什么是依赖注入如何依赖注入，首先我们要明确一些概念。 D...

    antz 评论0 收藏0

  • Spring框架之我见（三）——IOC、AOP

    摘要：模块负责的所有面向切面的功能。总结的统一管理，降低了对象之间的耦合对主流的框架提供了很好的集成支持提供众多组件，事务管理，等具有高度可开放性，开发者可以自由选择部分或全部主要使用工厂模式和代理模式。 聊完了Spring框架中最重要的两种设计模式，我们来看一下Spring框架的模块和结构图。 Spring框架的结构 下图是Spring官方给出的Spring框架的结构图。 showImg(...

    khs1994 评论0 收藏0

  • 深入理解依赖注入

    摘要：上面这部分代码不变，还是通过在构造器中传入依赖的方式初始化依赖调用这里，调用方无需了解内部对的依赖。而配置一般用于上自动扫描并注入的代码如下这里只给出直接在依赖对象上添加注解的形式，还可以通过构造器和注入依赖，这里就不多说了。 前言 相信所有面试java开发的童鞋一定都被问到过是否使用过Spring，是否了解其IOC容器，为什么不直接使用工厂模式，以及究竟IOC和DI区别在于哪里这种问...

    e10101 评论0 收藏0

  • Spring之旅第一站(不得不佩服老外...)

    摘要：表示少女与紧耦合在它的构造函数中自行创建了。面向切面编程往往被定义为促使软件系统实现关注点的分离一项技术系统由许多不同的组件组成，每个组件各负责一特定的功能。我们可以把切面想象为覆盖在很多组件之上的一个外壳。 第1章 Spring之旅 说明 1、本文抄写了《Spring 实战》重点内容，参考了GitHub上的代码 2、每个人的学习方式不一样，但目的是一样的，活学活用。最近一直在听《我...

    thekingisalwaysluc 评论0 收藏0

发表评论

登陆后可评论

0条评论

Cruise_Chan

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<