Java依赖注入容器超详细全面讲解

目录

• 一、依赖注入Dependency Injection
• 二、解析
• 2.1 典型的配置文件
• 2.2 配置文件所对应的Java类
• 2.3 定义解析器
• 三、bean工厂（根据bean定义创建bean对象）
• 四、DI容器（上下文）
• 4.1 容器接口
• 4.2 XML容器
• 五、使用DI容器

一、依赖注入Dependency Injection

DI容器底层最基本的设计思路就是基于工厂模式。

DI容器的核心功能：配置解析、对象创建、对象声明周期。

完整的代码：Dependency Injection。

二、解析

通过配置，让DI容器知道要创建哪些对象。

DI容器读取文件，根据配置文件来创建对象。

2.1 典型的配置文件

下面是一个典型的配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="productInfo" class="com.hef.review.designpatterns.creational.di.beans.ProductInfo">
        <constructor-arg type="String" value="P01"/>
        <constructor-arg type="int" value="200"/>
    </bean>
    <bean id="productSell" class="com.hef.review.designpatterns.creational.di.beans.ProductSell">
        <constructor-arg ref="productInfo"/>
    </bean>
</beans>

2.2 配置文件所对应的Java类

public class ProductInfo {
    private String productName;
    private int productVersion;
    public ProductInfo(String productName, int productVersion) {
        this.productName = productName;
        this.productVersion = productVersion;
    }
  // 省略 getter 和 setter
}
public class ProductSell {
    private ProductInfo productInfo;
    public ProductSell(ProductInfo productInfo) {
        this.productInfo = productInfo;
    }
    public void sell() {
        System.out.println("销售：" + productInfo);
    }
  // 省略 getter 和 setter
}

2.3 定义解析器

Bean定义：

/**
 * Bean定义
 */
public class BeanDefinition {
    private String id;
    private String className;
    private List<ConstructorArg> constructorArgs = new ArrayList<>();
    private Scope scope = Scope.SINGLETON;
    private boolean lazyInit = false;
    public BeanDefinition(){}
    public BeanDefinition(String id, String className) {
        this.id = id;
        this.className = className;
    }
  // 省略getter 和 setter方法
}

配置解析接口：

/**
 * 将XML配置解析成 Bean定义
 */
public interface BeanConfigParser {
    /**
     * 解析Bean定义
     * @param in
     * @return
     */
    List<BeanDefinition> parse(InputStream in);
}

XML解析实现（使用Java自带的DOM解析类库）：

/**
 * 解析XML，使用JDK自带的DOM解析类库
 */
public class BeanXmlConfigParser implements BeanConfigParser {
    /**
     * 根据流进行解析
     * @param in
     * @return
     */
    @Override
    public List<BeanDefinition> parse(InputStream in) {
        try {
            List<BeanDefinition> result = new ArrayList<>();
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            Document doc = documentBuilder.parse(in);
            doc.getDocumentElement().normalize();
            NodeList beanList = doc.getElementsByTagName("bean");
            for (int i = 0; i < beanList.getLength(); i++) {
                Node node = beanList.item(i);
                if (!Objects.equals(node.getNodeType(), Node.ELEMENT_NODE)) continue;
                Element element = (Element) node;
                BeanDefinition beanDefinition = new BeanDefinition(element.getAttribute("id"), element.getAttribute("class"));
                if (element.hasAttribute("scope")
                        && StringUtils.equals(element.getAttribute("scope"), BeanDefinition.Scope.PROTOTYPE.name())) {
                    beanDefinition.setScope(BeanDefinition.Scope.PROTOTYPE);
                }
                if (element.hasAttribute("lazy-init")
                        && Boolean.valueOf(element.getAttribute("lazy-init"))) {
                    beanDefinition.setLazyInit(true);
                }
                List<BeanDefinition.ConstructorArg> constructorArgs = createConstructorArgs(element);
                if (CollectionUtils.isNotEmpty(constructorArgs)) {
                    beanDefinition.setConstructorArgs(constructorArgs);
                }
                result.add(beanDefinition);
            }
            return result;
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 创建构造函数
     * @param element
     * @return
     */
    private List<BeanDefinition.ConstructorArg> createConstructorArgs(Element element) {
        List<BeanDefinition.ConstructorArg> result = new ArrayList<>();
        NodeList nodeList = element.getElementsByTagName("constructor-arg");
        if (nodeList.getLength()==0) return result;
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);
            if (!Objects.equals(node.getNodeType(), Node.ELEMENT_NODE)) continue;
            Element ele = (Element) node;
            BeanDefinition.ConstructorArg arg = new BeanDefinition.ConstructorArg();
            if (ele.hasAttribute("type") && StringUtils.isNoneBlank(ele.getAttribute("type"))) {
                String type = ele.getAttribute("type");
                String value = ele.getAttribute("value");
                arg.setType(fetchClassType(type));
                arg.setArg(fetchArgValue(type, value));
                arg.setRef(false);
            }else if (ele.hasAttribute("ref")) {
                arg.setRef(true);
                arg.setArg(ele.getAttribute("ref"));
            }
            result.add(arg);
        }
        return result;
    }
    /**
     * 获取构造函数 参数的值
     * @param typeValue
     * @param value
     * @return
     */
    private Object fetchArgValue(String typeValue, String value) {
        if (StringUtils.equals(typeValue, "int") || StringUtils.contains(typeValue, "Integer")) {
            return Integer.parseInt(value);
        }else if (StringUtils.contains(typeValue, "String")) {
            return value;
        } else {
            throw new RuntimeException("未知类型");
        }
    }
    /**
     * 获取构造函数的类型， 注意原始类型的 Class表示
     * @param typeValue
     * @return
     */
    private Class<?> fetchClassType(String typeValue) {
        if (StringUtils.equals(typeValue, "int")){
            return Integer.TYPE;
        } else if(StringUtils.contains(typeValue, "Integer")) {
            return Integer.class;
        }else if (StringUtils.contains(typeValue, "String")) {
            return String.class;
        } else {
            throw new RuntimeException("未知类型");
        }
    }
}

三、bean工厂（根据bean定义创建bean对象）

根据bean工厂创建bean的对象：

/**
 * bean工厂：利用反射， 根据Bean定义创建Bean对象
 */
public class BeansFactory {
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitions = new ConcurrentHashMap<>();
    /**
     * 向Bean工厂中，添加Bean定义
     * @param beanDefinitionList
     */
    public void addBeanDefinitions(List<BeanDefinition> beanDefinitionList) {
        for (BeanDefinition beanDefinition : beanDefinitionList) {
            this.beanDefinitions.putIfAbsent(beanDefinition.getId(), beanDefinition);
        }
        for (BeanDefinition beanDefinition : beanDefinitionList) {
            if (!beanDefinition.isLazyInit() && beanDefinition.isSingleton()) {
                singletonObjects.put(beanDefinition.getId(), createBean(beanDefinition));
            }
        }
    }
    /**
     * 根据beanId获取Bean对象
     * @param beanId
     * @return
     */
    public Object getBean(String beanId) {
        BeanDefinition beanDefinition = beanDefinitions.get(beanId);
        checkState(Objects.nonNull(beanDefinition), "Bean is not defined:" + beanId);
        return createBean(beanDefinition);
    }
    /**
     * 根据Bean定义创建Bean对象
     * @param beanDefinition
     * @return
     */
    private Object createBean(BeanDefinition beanDefinition) {
        if (beanDefinition.isSingleton() && singletonObjects.containsKey(beanDefinition.getId())) {
            return singletonObjects.get(beanDefinition.getId());
        }
        Object result = null;
        try {
            Class<?> beanClass = Class.forName(beanDefinition.getClassName());
            List<BeanDefinition.ConstructorArg> constructorArgs = beanDefinition.getConstructorArgs();
            if (CollectionUtils.isEmpty(constructorArgs)) {
                result =  beanClass.newInstance();
            } else {
                Class[] argClasses = new Class[constructorArgs.size()];
                Object[] argObjects = new Object[constructorArgs.size()];
                for (int k = 0; k < constructorArgs.size(); k++) {
                    BeanDefinition.ConstructorArg arg = constructorArgs.get(k);
                    if (!arg.isRef()) {
                        argClasses[k] = arg.getType();
                        argObjects[k] = arg.getArg();
                    } else {
                        BeanDefinition refBeanDefinition = beanDefinitions.get(arg.getArg());
                        checkState(Objects.nonNull(refBeanDefinition), "Bean is not defined: " + arg.getArg());
                        argClasses[k] = Class.forName(refBeanDefinition.getClassName());
                        argObjects[k] = createBean(refBeanDefinition);
                    }
                }
                result = beanClass.getConstructor(argClasses).newInstance(argObjects);
            }
            if (Objects.nonNull(result) && beanDefinition.isSingleton()) {
                singletonObjects.putIfAbsent(beanDefinition.getId(), result);
                return singletonObjects.get(beanDefinition.getId());
            }
            return result;
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

四、DI容器（上下文）

4.1 容器接口

/**
 * DI容器接口
 */
public interface ApplicationContext {
    Object getBean(String beanId);
    void loadBeanDefinitions(String configLocation);
}

4.2 XML容器

/**
 * XML DI容器上下文
 */
public class ClassPathXmlApplicationContext implements ApplicationContext {
    private BeansFactory beansFactory;
    private BeanConfigParser beanConfigParser;
    public ClassPathXmlApplicationContext(String configLocation) {
        this.beansFactory = new BeansFactory();
        this.beanConfigParser = new BeanXmlConfigParser();
        loadBeanDefinitions(configLocation);
    }
    /**
     * 根据配置文件路径，把XML文件 解析成 bean定义对象
     * @param configLocation
     */
    public void loadBeanDefinitions(String configLocation) {
        try (InputStream in = this.getClass().getClassLoader().getResourceAsStream(configLocation)) {
            if (in==null) {
                throw new RuntimeException("未发现配置文件:" + configLocation);
            }
            List<BeanDefinition> beanDefinitionList = beanConfigParser.parse(in);
            beansFactory.addBeanDefinitions(beanDefinitionList);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 从Bean工厂获取Bean对象
     * @param beanId
     * @return
     */
    @Override
    public Object getBean(String beanId) {
        return beansFactory.getBean(beanId);
    }
}

五、使用DI容器

/**
 * 使用DI容器，从获取中获取Bean对象
 */
public class Demo {
    public static void main(String[] args) {
//        testReadResourceXML();
//        testParseXML();
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Object productInfo = context.getBean("productInfo");
        System.out.println(productInfo);
        ProductSell productSell = (ProductSell)context.getBean("productSell");
        productSell.sell();
    }
  // 省略 testReadResourceXML() 和 testParseXML()
}

到此这篇关于Java依赖注入容器超详细全面讲解的文章就介绍到这了,更多相关Java依赖注入容器内容请搜索本网站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本网站！

您可能感兴趣的文章:

• Java详细讲解依赖注入的方式
• Java基础之教你如何正确运用依赖注入
• 如何用Java注解和反射实现依赖注入
• Java元注解meta-annotation和依赖注入详解
• JAVA使用quartz添加定时任务,并依赖注入对象操作
• JavaWeb Spring依赖注入深入学习
• 详解Java Spring各种依赖注入注解的区别
• 实例讲解Java的Spring框架中的控制反转和依赖注入