实现依赖注入（不使用框架）

墨蓝 2021-12-11 23:09 314阅读 0赞

转载自[https://www.cnblogs.com/bywallance/p/7295850.html][https_www.cnblogs.com_bywallance_p_7295850.html]

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

依赖注入的实现是基于反射实现的，因此不使用Spring框架实现依赖注入也是基于反射实现的。

### 文件的结构 ###

![20190709185926373.png][]

### 具体的实现如下： ###

1 首先定义一个利用反射获取类对象的方法，方法参数为类的全限定名称，代码如下：

/**
         * 利用反射，构造对象
         *
         * @param ClassName 类的全限定名
         * @return
         */
        public static Object getInstance(String ClassName) {
            Object result = null;   //定义为Object类，考虑到通用性
            try {
                result = Class.forName(ClassName).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;//返回构造出来的对象
        }

2 创建配置文件config.xml(注意：依赖注入在src文件夹下，而不在项目根目录下)，在配置文件中设置bean名称：

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
    <properties>
        <entry key="className">com.csu.UserImpl</entry> 
    </properties>

3 建立接口和接口的实现类，用于测试：

package com.csu;
    
    //接口
    public interface User {
        void sayHello();
    }

package com.csu;
    
    //接口的实现类
    public class UserImpl implements User {
    
        //实现接口的方法
        public void sayHello() {
            System.out.println("Hello World!");
        }
    }

4 对依赖注入进行测试：

package com.csu;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    
    /**
     * 依赖注入的实现是基于反射实现的，因此不使用Spring框架实现依赖注入也是基于反射实现的。
     */
    public class DependencyInjection {
    
        /**
         * 利用反射，构造对象
         *
         * @param ClassName 类的全限定名
         * @return
         */
        public static Object getInstance(String ClassName) {
            Object result = null;   //定义为Object类，考虑到通用性
            try {
                result = Class.forName(ClassName).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;//返回构造出来的对象
        }
    
    
        /* 根据xml配置文件里面的信息，去反射出相应的对象。没有自己去new */
        public static void main(String[] args) throws IOException {
            //载入配置信息
            InputStream inputStream=(InputStream)ClassLoader.getSystemResourceAsStream("config.xml");//读取到项目根目录的config.xml文件
            Properties properties = new Properties();
            properties.loadFromXML(inputStream);/*根据配置文件，构造Properties对象*/
    
            //从config.xml中，读取beanName
            String ClassName = properties.getProperty("className"); /* 从config.xml里面，读取出“className”对应的值（即类的全限定名） */
            User user = (User) getInstance(ClassName); //根据beanName，利用“反射”获取对象
            user.sayHello();
    
            // 在程序中没有没有去new对象，而是交给getInstance（）方法去new对象.
            //代码会根据配置文件得到bean信息，然后去new配置文件中bean对象，将依赖注入到这里。（本例中注入了User对象进来）
            //如果要使用的实现类出现了变化，那么只需要修改xml配置文件中的信息就可以，大大减少了修改代码的成本.
        }
    }

5 运行结果如下：

![20190709190434659.png][]

在程序中没有没有去new对象，而是交给getInstance（）方法去new对象。

代码会根据配置文件得到bean信息，然后去new配置文件中bean对象，将依赖注入到这里。

如果要使用的实现类出现了变化，那么只需要修改xml配置文件中的信息就可以，大大减少了修改代码的成本。

通过以上代码就简单的实现了依赖注入。

[https_www.cnblogs.com_bywallance_p_7295850.html]: https://www.cnblogs.com/bywallance/p/7295850.html
[20190709185926373.png]: /images/20211211/f8eb5498ee86479cb4582d3512c858c5.png
[20190709190434659.png]: /images/20211211/b97b262bb7ec4c2aa7eeab735d3b43b7.png