Simple IOC 容器实现-基于XML方式

最新推荐文章于 2024-08-17 17:00:00 发布
最新推荐文章于 2024-08-17 17:00:00 发布
阅读量1k 收藏
点赞数
分类专栏： Architecture 文章标签： ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/top_code/article/details/51429803
版权

概述

IOC（Inversion of Control）“控制反转”，不过更流行的叫法是“依赖注入”（DI - Dependency Injection）。

什么是“控制反转”呢？其实就是将控制权（创建对象和对象之间的依赖关系的权利）交给Spring容器。以前我们写代码的需要某个对象的时候直接使用 new XXXImpl();，有了Spring IOC容器之后，它负责对象的创建和依赖注入，当我们需要某个对象时直接跟Spring IOC容器要就好了。

IOC 听起来很高大上，其实实现起来并不复杂。本文主要介绍基于XML配置的方式来实现一个IOC容器，后面会有单独的一章介绍如何通过注解的方式来实现IOC容器。

用法

具体用法与Spring IOC类似，如下：

1、beans.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  

    <bean id="userDao" class="com.ricky.ioc.sample.dao.UserDaoImpl" scope="singleton" init-method="init" ></bean>

    <bean id="userService" class="com.ricky.ioc.sample.service.UserServiceImpl">  
        <property name="userDao" ref="userDao"></property>  
    </bean>

    <bean id="userController" class="com.ricky.ioc.sample.controller.UserController">  
        <property name="userService" ref="userService"></property>  
    </bean>
</beans>

2、添加maven依赖

<dependency>
    <groupId>com.ricky.framework</groupId>
    <artifactId>ioc</artifactId>
    <version>1.0.0</version>
</dependency>

3、加载bean配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

//通过id获取Bean
UserController userController =(UserController)ctx.getBean("userController");
userController.login("ricky", "123");

//通过Class获取Bean
UserService userService = ctx.getBean(UserService.class);
System.out.println(userService);
userService.login("ricky", "abc");

ctx.close();

运行结果如下：

UserController login name->ricky,password->123
UserServiceImpl login name->ricky,password->123
UserDaoImpl find name->ricky
com.ricky.ioc.sample.service.UserServiceImpl@214c265e
UserServiceImpl login name->ricky,password->abc
UserDaoImpl find name->ricky
container close…

具体实现

思路：
解析beans.xml获取Bean列表以及相互之间的依赖关系，然后通过反射技术构造出Bean实例，并根据Bean之间的依赖关系进行Bean装配。

首先，看看ApplicationContext类，代码如下：

package com.ricky.framework.ioc;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.commons.lang3.StringUtils;

import com.ricky.framework.ioc.model.BeanDefinition;
import com.ricky.framework.ioc.model.PropertyDefinition;
import com.ricky.framework.ioc.util.ReflectionUtils;

public abstract class ApplicationContext {

    public abstract Object getBean(String id);

    public abstract <T> T getBean(Class<T> clazz);

    public abstract void close();

    protected abstract BeanDefinition getBeanDefinition(String id);

    protected Object createBean(BeanDefinition bd) {

        try {
            Object bean = ReflectionUtils.newInstance(bd.getClassName());
            if(StringUtils.isNotEmpty(bd.getInitMethodName())){
                ReflectionUtils.invokeMethod(bean, bd.getInitMethodName());
            }

            return bean;
        } catch (ClassNotFoundException | InstantiationException
                | IllegalAccessException | IllegalArgumentException
                | InvocationTargetException | NoSuchMethodException e) {
            throw new RuntimeException("create bean error, class->"+bd.getClassName(), e);
        }
    }

    protected void injectBeanProperties(Object bean, BeanDefinition beanDefinition){

        try {
            PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();  

            for(PropertyDefinition propertyDefinition : beanDefinition.getProperties()){  

                for(PropertyDescriptor propertyDescriptor:ps){

                    if(propertyDescriptor.getName().equals(propertyDefinition.getName())){  

                        Method setter = propertyDescriptor.getWriteMethod(); 
                        setter.setAccessible(true); 

                        setter.invoke(bean, getBean(propertyDefinition.getRef()));  
                    }
                }
            }
        } catch (SecurityException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException
                | IntrospectionException e) {
            throw new RuntimeException("inject bean properties error", e);
        }
    }
}

在这涉及到两个关键类：BeanDefinition 和 PropertyDefinition，它们分别是用来描述 javabean的定义和javabean 属性的定义，一个BeanDefinition 可以有1个或多个PropertyDefinition，它们之间是1：N的关系。代码如下：

BeanDefinition.java

package com.ricky.framework.ioc.model;

import java.util.List;

public class BeanDefinition {
    private String id;
    private String className;
    private String scope;   //singleton|prototype
    private String initMethodName;
    private List<PropertyDefinition> properties;

    public BeanDefinition(String id, String className) {  
        this.id = id;  
        this.className = className;  
    }

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    public String getScope() {
        return scope;
    }
    public void setScope(String scope) {
        this.scope = scope;
    }
    public String getInitMethodName() {
        return initMethodName;
    }
    public void setInitMethodName(String initMethodName) {
        this.initMethodName = initMethodName;
    }
    public List<PropertyDefinition> getProperties() {
        return properties;
    }
    public void setProperties(List<PropertyDefinition> properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "BeanDefinition [id=" + id + ", className=" + className
                + ", scope=" + scope + ", initMethodName=" + initMethodName
                + ", properties=" + properties + "]";
    }

}

PropertyDefinition.java

package com.ricky.framework.ioc.model;

public class PropertyDefinition {  
    private String name;
    private String ref;

    public PropertyDefinition(String name, String ref) {  
        this.name = name;  
        this.ref = ref;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getRef() {  
        return ref;  
    }  
    public void setRef(String ref) {  
        this.ref = ref;  
    }

    @Override
    public String toString() {
        return "PropertyDefinition [name=" + name + ", ref=" + ref + "]";
    }

}

2、接下来是ClassPathXmlApplicationContext类，代码如下：

package com.ricky.framework.ioc;

import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.dom4j.DocumentException;

import com.ricky.framework.ioc.model.BeanDefinition;
import com.ricky.framework.ioc.parser.BeanXmlConfigParser;
import com.ricky.framework.ioc.util.BeanScope;
import com.ricky.framework.ioc.util.ReflectionUtils;

public class ClassPathXmlApplicationContext extends ApplicationContext {

    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();
    protected Map<String, Object> beanInstanceMap = new HashMap<String, Object>();

    public ClassPathXmlApplicationContext(String xmlFilePath) {

        System.out.println("****************container init begin****************");

        readXml(xmlFilePath);
        initBeans();
        injectBeans();

        System.out.println("****************container init end****************");
    }

    private void readXml(String xmlFilePath) {

        BeanXmlConfigParser beanXmlConfigParser = new BeanXmlConfigParser();

        List<BeanDefinition> bean_def_list = null;
        try {
            bean_def_list = beanXmlConfigParser.parse(xmlFilePath);
        } catch (FileNotFoundException e) {
            throw new RuntimeException("not found bean xml, file->"+xmlFilePath, e);
        } catch (DocumentException e) {
            throw new RuntimeException("bean xml format error, file->"+xmlFilePath, e);
        }

        for (BeanDefinition beanDefinition : bean_def_list) {

            if(StringUtils.isEmpty(beanDefinition.getId()) || StringUtils.isEmpty(beanDefinition.getClassName())){
                throw new IllegalArgumentException("bean definition is empty!");
            }

            if (beanDefinitionMap.containsKey(beanDefinition.getId())) {
                throw new IllegalArgumentException(
                        "duplicated bean id , id->"
                                + beanDefinition.getId());
            }

            beanDefinitionMap.put(beanDefinition.getId(), beanDefinition);
        }
    }

    private void initBeans() {

        for (Map.Entry<String, BeanDefinition> me : beanDefinitionMap.entrySet()) {

            BeanDefinition bd = me.getValue();
            if(StringUtils.isEmpty(bd.getScope()) || bd.getScope().equals(BeanScope.SINGLETON)){
                try {
                    Object bean = createBean(bd);
                    beanInstanceMap.put(bd.getId(), bean);
                } catch (Exception e) {
                    throw new IllegalArgumentException("create bean error,class->"+bd.getClassName(), e);
                }
            }
        }
    }

    private void injectBeans() {

        for (Map.Entry<String, BeanDefinition> me : beanDefinitionMap.entrySet()) {

            BeanDefinition beanDefinition = me.getValue();
            //判断有没有注入属性  
            if (beanDefinition.getProperties() != null && beanDefinition.getProperties().size()>0) {  

                Object bean = beanInstanceMap.get(beanDefinition.getId());  
                try {
                    injectBeanProperties(bean, beanDefinition);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }  
        }  
    }

    @Override
    public Object getBean(String id) {

//      System.out.println("get bean by id:"+id);

        if (StringUtils.isEmpty(id)) {
            return null;
        }

        if (beanDefinitionMap.containsKey(id)) {

            BeanDefinition bd = beanDefinitionMap.get(id);

            if(StringUtils.isEmpty(bd.getScope()) || bd.getScope().equals(BeanScope.SINGLETON)){

                return beanInstanceMap.get(id);
            }

            Object bean = null;
            try {
                bean = createBean(bd);
                injectBeanProperties(bean, bd);
                beanInstanceMap.put(bd.getId(), bean);
            } catch (Exception e) {
                e.printStackTrace();
            }

            return bean;
        }
        throw new IllegalArgumentException("unknown bean, id->" + id);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T getBean(Class<T> clazz) {

//      System.out.println("get bean by type:"+clazz.getName());

        for(Map.Entry<String, BeanDefinition> me : beanDefinitionMap.entrySet()){

            BeanDefinition bd = me.getValue();
            Class<?> beanClass = null;
            try {
                beanClass = ReflectionUtils.loadClass(bd.getClassName());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

            if(beanClass!=null && clazz.isAssignableFrom(beanClass)){
//              System.out.println("find bean by type, class->"+clazz.getName());
                return (T) getBean(bd.getId());
            }
        }

        return null;
    }

    @Override
    protected BeanDefinition getBeanDefinition(String id) {

        return beanDefinitionMap.get(id);
    }

    @Override
    public void close() {

        System.out.println("container close...");

        // release resource
        beanDefinitionMap.clear();
        beanDefinitionMap = null;

        beanInstanceMap.clear();
        beanInstanceMap = null;
    }

}

在ClassPathXmlApplicationContext类中，主要负责三大功能：解析XML配置文件、通过反射构建Bean实例以及对Bean进行装配。


小结

以上所有代码均已上传到GitHub上，欢迎大家fork。另外由于时间比较仓促，代码设计上有不合理的地方还请包涵，后面会抽时间对代码进行重构。

Ricky_Fung
关注
专栏目录
实现一个简易的IoC容器
水木今山的博客
03-20 371
Simple IoC 仿照 Spring 实现的一个简易版的 IoC 容器。 项目地址：simple-ioc Features 支持根据指定的路径从文件系统中获取资源 支持XSD模式的XML验证 支持<property/>标签以及value与ref属性（即字符串与引用类型的属性注入） 支持单例与原型Bean，并通过三级缓存解决了单例Bean的循环依赖问题 Blog 资源加载 注册...
细说Spring——IoC详解（XML配置一）
啦啦啦的博客
05-14 4043
在我们经过了： 细说Spring——IoC详解（一） 细说Spring——IoC详解（二） 细说Spring——IoC详解（三） 的学习之后，已经对Spring的Ioc容器有了一定的了解，我们队容器如何创建对象有了细致的了解，接下来就是一些其他零零散散的东西，这一期就主要讲解Spring IoC容器的XML配置文件。 一、我们应该怎么理解和认识Spring的配置文件呢？ 其实，Sp...
Spring学习笔记之一----基于XML的Spring IOC配置
weixin_30266885的博客
11-18 88
1. 在spring配置文件中，如果对一个property进行直接赋值，可使用<value>元素，spring负责将值转化为property指定的类型；也可以直接在property元素上使用value属性来赋值； 2. 构造函数注入，应使用<constructor-arg>元素来赋值，该元素有三个属性，你可以指定来对赋值的构造函数参数进行区分：type、inde...
IOC--自定义IOC容器
最新发布
代码改变世界
08-17 218
IOC--自定义IOC容器 讲解IOC容器思想，自定义完成常用IOC的逻辑
Simple IOC 容器实现-基于注解
Ricky
05-19 2112
Simple IOC 容器实现-基于注解配置
SpringIOC学习笔记（一）------xml方式实现IOC
小生不才
12-11 234
一、Spring框架简述 Spring是一个非常活跃的开源框架, 它是一个基于IOC和AOP来构架多层JavaEE系统的框架,它的主要目地是简化企业开发。 Spring以一种非侵入式的方式来管理你的代码, Spring提倡“最少侵入”，这也就意味着你可以适当的时候安装或卸载Spring。 Spring采用独立的模块式开发，这样可以有选择的使用其中的模块，降低了业务对象的复杂性和组件之间的耦合...
Spring--基于XML的IOC细节
破茧成蝶
06-12 302
目录bean标签 前面说到spring中Bean有三种配置方式： https://blog.csdn.net/Sunny5319/article/details/90740358 下面梳理一下基于XML的配置方式及其细节 bean标签 作用 1.用于配置对象让 spring 来创建的。 2.默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。 属性 id： 给对象在容器中...
simple-springioc:这是一个简单的SpringIOC
05-11
随着Spring的发展，IoC容器也不断演进，包括引入了基于注解的配置、自动扫描、Profile支持等功能，极大地简化了开发工作。例如，我们可以使用`@Component`、`@Service`、`@Repository`和`@Controller`等注解标记Bean...
doodle:A Simple Java MVC Framework。提供Bean容器、Ioc、Aop、MVC功能
05-07
IOC容器，解决循环依赖注入问题 支持多AOP增强，切点支持aspectj表达式 Http请求访问设计图： 示例代码 git clone https://github.com/zzzzbw/doodle.git 或直接下载代码到本地 将项目导入到IDE中，这是maven工程,...
Spring boot实现一个简单的ioc（1）
08-30
在本文中，我们将创建一个简易的IOC容器，以理解其工作原理，并在实际项目中实现类似Spring Boot的自动装配功能。 首先，我们定义测试项目结构。项目包含以下几个关键组件： 1. **SampleApplication**：这是项目的...
工厂模式的测试并有spring ioc的简单实现
05-07
在Spring中，工厂模式可以与IoC容器结合使用，例如在【springFactory】和【springFactoryJDOM】的示例中，我们可能会看到如何使用Spring的Bean工厂来创建和管理对象。Spring提供了XML配置和注解两种方式来声明和管理...
Spring入门（一）基于XML的IOC配置
stevensam_lin的博客
09-04 267
一、概述 1、spring的概述 Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架（来自百度百科）。 2、控制反转（Inversion of Control，缩写为IoC）是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependenc...
基于xml方式自定义实现Ioc容器
.
11-20 451
文章目录xml方式自定义实现Ioc容器前言没有IOC容器的时候模拟银行转账例子使用Ioc容器情况下IoC解决了什么问题 xml方式自定义实现Ioc容器 使用xml实现自定义简单的Ioc容器 前言 平时开发过程中,我们都是使用Spring来进行开发,Spring核心的Ioc容器帮助我们去创建对象这一过程被称作控制反转也叫Ioc 在实例化一个对象时候,这个对象中用到一个对象类型的属性,容器把这个对象注入到实例化对象的过程被称作依赖注入简称DI Ioc和DI说的是一个事情,针对的侧重点不同,IOC是站在容器角度创
自动动手实现一个IOC-simpleioc
weixin_34117522的博客
04-25 199
我们都知道 Spring 的两大核心是IOC 和 AOP。也有人认为是IOC、DI和AOP。这几项应该是所有的java后台都应该掌握的。所以为了加深对这几个概念的理解，本人根据自己的理解动手实现了一个简单的IOC。 github地址 1.概念理解 IOC:(Inversion of Control) 控制反转，是一种设计思想。包含了两方面：一、控制，二、反转。控制指的是当前对象对...
基于xml的ioc案例以及注解ioc案例
Hello_MAOSONG的博客
05-20 303
1.环境搭建pom.xml <packaging>jar</packaging> <dependencies> <!--spring坐标--> <dependency> <groupId>org.springframework</groupId> <artif...
Spring笔记（一）——xml方式实现IoC和DI
jialiang的博客
07-14 788
javaweb开发中，几乎离不开各种开源框架的支持。 javaweb的开发分为三个层次： WEB层 （表现层） 业务层 – Bean管理:(IOC) 持久层 – Spring的JDBC模板.ORM模板用于整合其他的持久层框架 在这三个层次中，常用的框架结构有SSH和SSM。无论是SSH还是SSM，业务层都是由Spring来实现的。因此，Spring框架对于javaweb开发非常重
基于xml的IOC容器
qq_36609994的博客
02-09 169
话不多说，开干… 1、创建spring.xml文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
IOC与DI系列：3 基于XMl的IOC的实现过程
纵横千里 捭阖四方 的专栏
04-07 260
1.IOC的概念 通俗地说，IOC就是读取xml或者注解配置的类信息，将其存储到一个Map里，然后将这些类进行初始化，也放到Map里，程序在使用的时候直接从Map里读取就好了。读取的过程就是IOC，根据依赖关系进行完整初始化的过程就是DI。而最后的这个map就是Spring容器。 规范一点说，IOC就是把原先代码里需要实现的对象创建，依赖和管理的工作交给容器帮我们做。 那么必然我们需要创建一个容器，同时需要一种描述来让容器知道需要创建的对象与对象之间的关系。这个描述就是配置文件或者注解。 DI依赖注入就是指
Spring——IOC容器简单运用
qq_44730336的博客
03-27 894
IoC也被称为依赖注入（DI）。这是一个过程，对象仅通过构造函数参数、工厂方法的参数或在对象实例构造或从工厂方法返回后在对象实例上设置的属性来定义它们的依赖关系（即它们使用的其他对象）。然后，容器在创建bean时注入这些依赖项。这个过程基本上是bean本身的逆过程（因此称为控制反转），通过使用类的直接构造或服务定位器模式等机制来控制其依赖项的实例化或位置。 1、导入依赖 org.springframework.beans 和org.springframework.context是Spring框架的IoC.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值