简易ioc容器实现

最新推荐文章于 2023-03-17 23:04:20 发布
最新推荐文章于 2023-03-17 23:04:20 发布
阅读量123 收藏
点赞数
分类专栏： 互联网系统设计 文章标签： java spring mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011955252/article/details/128943907
版权 
package com.summer.simplespringioc.model;

import lombok.Data;

/**
 * bean property配置
 *
 * @author summer
 * @version $Id: BeanPropertyConfig.java, v 0.1 2022年02月14日 9:27 AM summer Exp $
 */
@Data
public class BeanPropertyConfig {
    //属性名
    private String name;
    //属性值
    private String value;
    //属性的值是否引用其他bean
    private Boolean isValueRef;
}
package com.summer.simplespringioc.model;

import lombok.Data;

/**
 * constructor arg配置
 *
 * @author summer
 * @version $Id: ConstructorPropertyConfig.java, v 0.1 2022年02月14日 9:27 AM summer Exp $
 */
@Data
public class ConstructorPropertyConfig {
    //属性值
    private String value;
    //属性的值是否引用其他bean
    private Boolean isValueRef;
}
package com.summer.simplespringioc.util;

import org.apache.commons.lang3.StringUtils;

/**
 * 基础工具类
 *
 * @author summer
 * @version $Id: BaseUtils.java, v 0.1 2022年02月27日 5:29 PM summer Exp $
 */
public class BaseUtils {

    /**
     * 首字符大写
     *
     * @param s 字符串
     * @return
     */
    public final static String upperFirstChar(String s) {
        if (StringUtils.isBlank(s)) {
            return s;
        }

        char chars[] = s.toCharArray();
        chars[0] = Character.toUpperCase(s.charAt(0));
        return new String(chars);
    }

    /**
     * 将字符串类型的值转换为特定基础类型的值
     *
     * @param s
     * @return
     */
    public final static Object convertBaseDataType(String s, String type) {
        if (StringUtils.equals("java.lang.Integer", type)) {
            return Integer.valueOf(s);
        } else if (StringUtils.equals("java.lang.Long", type)) {
            return Long.valueOf(s);
        } else if (StringUtils.equals("java.lang.Double", type)) {
            return Double.valueOf(s);
        } else if (StringUtils.equals("java.lang.String", type)) {
            return s;
        }

        return null;
    }
}
package com.summer.simplespringioc;

import com.summer.simplespringioc.model.BeanPropertyConfig;
import com.summer.simplespringioc.model.ConstructorPropertyConfig;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * bean定义领域模型
 *
 * @author summer
 * @version $Id: SimpleBeanDefinition.java, v 0.1 2022年02月10日 9:09 AM summer Exp $
 */
@Data
public class SimpleBeanDefinition {
    private String                          id;
    private String                          className;
    private List<ConstructorPropertyConfig> constructArgs = new ArrayList<>();
    private List<BeanPropertyConfig>        properties    = new ArrayList<>();
}
package com.summer.simplespringioc;

import com.summer.simplespringioc.model.BeanPropertyConfig;
import com.summer.simplespringioc.model.ConstructorPropertyConfig;
import com.summer.simplespringioc.util.BaseUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * spring ioc容器实现
 *
 * @author summer
 * @version $Id: SimpleBeanIocContainer.java, v 0.1 2022年02月10日 9:12 AM summer Exp $
 */
@Slf4j
public class SimpleBeanIocContainer {

    //bean定义相关标签
    private final static String BEAN_CONFIG_ATTR_ID = "id";
    private final static String BEAN_CONFIG_ATTR_CLASS_NAME = "class";
    private final static String BEAN_CONFIG_ATTR_CONSTRUCTOR_ARG = "constructor-arg";
    private final static String BEAN_CONFIG_ATTR_REF = "ref";
    private final static String BEAN_CONFIG_ATTR_PROPERTY = "property";
    private final static String BEAN_CONFIG_ATTR_NAME = "name";
    private final static String BEAN_CONFIG_ATTR_VALUE = "value";
    private final static String BEAN_CONFIG_ATTR_BEAN = "bean";

    /**
     * 存放bean定义的map,key-bean id
     */
    private final Map<String, SimpleBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

    /**
     * 存放单例bean的本地缓存
     */
    private final Map<String, Object> singletonBeans = new ConcurrentHashMap<>();

    /**
     * 初始化
     *
     * @param file 配置文件
     */
    public void init(String file) {
        //加载xml文件，解析bean的定义
        this.loadBeanDefinitionFromFile(file);

        //注册bean到容器
        registerBean();

        log.info("singletonBeans=" + singletonBeans);
    }

    /**
     * 注册bean到容器
     */
    private void registerBean() {
        for (Map.Entry<String, SimpleBeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanId = entry.getKey();

            getSingletonBean(beanId);
        }
    }

    /**
     * 获取bean（单例）
     *
     * @param beanId bean id
     * @return
     */
    private Object getSingletonBean(String beanId) {
        Object beanObject = singletonBeans.get(beanId);
        if (beanObject != null) {
            return beanObject;
        }

        SimpleBeanDefinition beanDefinition = beanDefinitionMap.get(beanId);
        log.info("create singleton bean begin....beanid=" + beanId + ",beanDefinition=" + beanDefinition);

        beanObject = createBean(beanDefinition);

        singletonBeans.put(beanId, beanObject);

        return beanObject;
    }

    /**
     * 创建bean实例
     *
     * @param beanDefinition
     * @return
     */
    private Object createBean(SimpleBeanDefinition beanDefinition) {
        //初始化bean
        Object beanInstance = initBean(beanDefinition);

        //bean属性注入
        populateBeanProps(beanInstance, beanDefinition);

        return beanInstance;
    }

    /**
     * bean属性注入
     *
     * @param beanInstance bean
     * @param beanDefinition bean定义
     */
    private void populateBeanProps(Object beanInstance, SimpleBeanDefinition beanDefinition) {
        try {
            List<BeanPropertyConfig> propertyConfigs = beanDefinition.getProperties();
            Method[] methods = beanInstance.getClass().getDeclaredMethods();
            for (Method method : methods) {
                for (BeanPropertyConfig beanPropertyConfig : propertyConfigs) {
                    if (StringUtils.equals(method.getName(), "set" + BaseUtils.upperFirstChar(beanPropertyConfig.getName()))) {
                        //通过反射调用set方法进行属性值的设置。有可能是基础类型值，也可能是另一个bean。
                        Object propValue = null;
                        if (beanPropertyConfig.getIsValueRef()) {
                            propValue = getSingletonBean(beanPropertyConfig.getValue());
                        } else {
                            //beanDefinition中存的值是String，需要转换为特定的基础类型
                            Type[] types = method.getParameterTypes();
                            propValue = BaseUtils.convertBaseDataType(beanPropertyConfig.getValue(), types[0].getTypeName());
                        }

                        log.info("method=" + method.getName() + ",propValue=" + propValue + ",beanPropertyConfig=" + beanPropertyConfig + ",beanDefinition=" + beanDefinition);

                        method.invoke(beanInstance, propValue);
                    }
                }
            }
        } catch (Exception e) {
            log.error("populateBeanProps exception,beanDefinition=" + beanDefinition, e);
        }
    }

    /**
     * 初始化bean
     *
     * @param beanDefinition bean定义
     * @return
     */
    private Object initBean(SimpleBeanDefinition beanDefinition) {
        //如果有构造函数配置，调用构造进行实例化
        if (CollectionUtils.isNotEmpty(beanDefinition.getConstructArgs())) {
            return createBeanByConstructor(beanDefinition);
        }

        return createBeanByClassloader(beanDefinition);
    }

    /**
     * 通过构造函数创建bean
     *
     * @param beanDefinition bean定义
     * @return
     */
    private Object createBeanByConstructor(SimpleBeanDefinition beanDefinition) {
        log.info("createBeanByConstructor begin....");
        try {
            Constructor<?> constructor = null;//构造函数匹配
            Object[] args = null;//参数

            Class<?> beanClass = Thread.currentThread().getContextClassLoader().loadClass(beanDefinition.getClassName());
            Constructor<?>[] constructors = beanClass.getDeclaredConstructors();

            //根据构造函数参数长度匹配对应的构造函数
            for (int i = 0;i < constructors.length;++i) {
                Class<?>[] paramTypes = constructors[i].getParameterTypes();
                if (paramTypes.length != beanDefinition.getConstructArgs().size()) {
                    continue;
                }

                constructor = constructors[i];

                //参数组装（可能是基础类型，也可能是bean注入）
                args = new Object[paramTypes.length];
                for (int j = 0;j < beanDefinition.getConstructArgs().size(); ++j) {
                    ConstructorPropertyConfig constructorPropertyConfig = beanDefinition.getConstructArgs().get(j);
                    if (constructorPropertyConfig.getIsValueRef()) {
                        args[j] = getSingletonBean(constructorPropertyConfig.getValue());
                    } else {
                        args[j] = constructorPropertyConfig.getValue();
                    }
                }
                break;
            }

            //创建bean
            return constructor.newInstance(args);
        } catch (Exception e) {
            log.error("createBeanByConstructor exception,beanDefinition=" + beanDefinition);
            return null;
        }
    }

    /**
     * get bean object by bean id
     *
     * @param beanDefinition
     * @return
     */
    public static Object createBeanByClassloader(SimpleBeanDefinition beanDefinition) {
        log.info("createBeanByClassloader begin....");
        try {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            Class<?> clz = classLoader.loadClass(beanDefinition.getClassName());
            return clz.newInstance();
        } catch (Exception e) {
            log.error("createBeanByClassloader exception", e);
            return null;
        }
    }

    /**
     * 解析XML文件加载bean定义
     *
     * @param file 文件名
     */
    private void loadBeanDefinitionFromFile(String file) {
        log.info("loadBeanDefinitionFromFile begin");

        InputStream inputStream = null;
        try {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

            //获取配置文件的文件流
            inputStream = classLoader.getResourceAsStream(file);

            SAXReader reader = new SAXReader();
            Document document = reader.read(inputStream);

            Element rootElement = document.getRootElement();
            Iterator iterator = rootElement.elementIterator();

            //遍历bean的定义配置
            while (iterator.hasNext()) {
                Element loopElement = (Element) iterator.next();
                String beanId = loopElement.attributeValue(BEAN_CONFIG_ATTR_ID);
                String beanclass = loopElement.attributeValue(BEAN_CONFIG_ATTR_CLASS_NAME);
                if (StringUtils.isBlank(beanId) || StringUtils.isBlank(beanclass)) {
                    log.error("loadBeanDefinitionFromFile xml parse,bean definition illegal:[" + beanId + "," + beanclass + "]");
                    continue;
                }

                //SimpleBeanDefinition构造
                SimpleBeanDefinition simpleBeanDefinition = new SimpleBeanDefinition();
                simpleBeanDefinition.setId(beanId);
                simpleBeanDefinition.setClassName(beanclass);

                //构造函数定义解析
                parseConstructorArg(loopElement, simpleBeanDefinition);

                //property定义解析
                parseProperties(loopElement, simpleBeanDefinition);

                beanDefinitionMap.put(beanId, simpleBeanDefinition);
            }

            log.info("loadBeanDefinitionFromFile,eanDefinitionMap=" + beanDefinitionMap);
        } catch (Exception e) {
            log.error("loadBeanDefinitionFromFile exception,file=" + file, e);
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    log.error("close inputstream exception,file=" + file, e);
                }
            }
        }
    }

    /**
     * get bean definition by bean id
     *
     * @param beanId
     * @return
     */
    public SimpleBeanDefinition getBeanDefinition(String beanId) {
        return beanDefinitionMap.get(beanId);
    }

    /**
     * 构造函数配置解析
     *
     * @param element
     * @param simpleBeanDefinition
     */
    private void parseConstructorArg(Element element, SimpleBeanDefinition simpleBeanDefinition) {
        Iterator iterator = element.elementIterator(BEAN_CONFIG_ATTR_CONSTRUCTOR_ARG);
        while (iterator.hasNext()) {
            Element propertyElement = (Element) iterator.next();
            String ref = propertyElement.attributeValue(BEAN_CONFIG_ATTR_REF);
            String value = propertyElement.attributeValue(BEAN_CONFIG_ATTR_REF);
            if (StringUtils.isBlank(ref) && StringUtils.isBlank(value)) {
                log.error("parseConstructorArg config illegal,propertyElement=" + propertyElement);
                return;
            }

            ConstructorPropertyConfig constructorPropertyConfig = new ConstructorPropertyConfig();
            if (StringUtils.isNotBlank(ref)) {
                constructorPropertyConfig.setValue(ref);
                constructorPropertyConfig.setIsValueRef(true);
            } else {
                constructorPropertyConfig.setValue(value);
            }

            simpleBeanDefinition.getConstructArgs().add(constructorPropertyConfig);
        }
    }

    /**
     * property配置解析
     *
     * @param beanElem
     * @param simpleBeanDefinition
     */
    private void parseProperties(Element beanElem, SimpleBeanDefinition simpleBeanDefinition) {
        Iterator iterator = beanElem.elementIterator(BEAN_CONFIG_ATTR_PROPERTY);
        //遍历所有property配置
        while (iterator.hasNext()) {
            Element propElem = (Element) iterator.next();
            String propertyName = propElem.attributeValue(BEAN_CONFIG_ATTR_NAME);
            if (StringUtils.isBlank(propertyName)) {
                return;
            }

            BeanPropertyConfig beanPropertyConfig = new BeanPropertyConfig();
            beanPropertyConfig.setName(propertyName);

            //property的配置值可能是value也可能是ref
            String value = propElem.attributeValue(BEAN_CONFIG_ATTR_VALUE);
            if (StringUtils.isNotBlank(value)) {
                beanPropertyConfig.setValue(value);
                beanPropertyConfig.setIsValueRef(false);
            } else {
                Iterator propertyRefIterator = propElem.elementIterator(BEAN_CONFIG_ATTR_REF);
                Element refElem = (Element) propertyRefIterator.next();
                String refBean = refElem.attributeValue(BEAN_CONFIG_ATTR_BEAN);
                beanPropertyConfig.setValue(refBean);
                beanPropertyConfig.setIsValueRef(true);
            }

            simpleBeanDefinition.getProperties().add(beanPropertyConfig);
        }
    }
}
package com.summer.simplespringioc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SimplespringiocApplication {

	public static void main(String[] args) {
		SpringApplication.run(SimplespringiocApplication.class, args);
	}

}

红豆和绿豆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IOC的基本概念，IoC容器的实现方式有哪些？
javamyfriend的博客
06-14 328
Spring IOC的基本概念，IoC容器的实现方式有哪些？
IOC基础
Angel__wings的博客
07-25 2306
组件必须自己使用容器提供的API来查找资源和协作对象，控制反转仅体现在那些回调方法上，容器调用这些回调方法，从而应用代码获取到资源。通常，我们实例化一个对象时，都是使用类的构造方法来new一个对象，这个过程是由我们自己来控制的，而控制反转就把new对象的工作交给了Spring容器。第三、具体到IOC框架产品(Spring)来讲，需要进行大量的配制工作，比较繁琐，对于一些小的项目而言，客观上也可能加大一些工作成本。ioc是把需要使用的对象提前创建好，放到spring的容器里面。......
如何实现一个IOC容器
wei7a7a7a的博客
03-17 71
4、进行对象的初始化操作，也就是给类中的对应属性值就行设置，也就是进行依赖注入，完成整个对象的创建，变成一个完整的bean对象，存储在容器的某个map结构中。2、进行配置文件的读取工作或者注解的解析工作，将需要创建的bean对象都封装成BeanDefinition对象存储在容器中。3、容器将封装好的BeanDefinition对象通过反射的方式进行实例化，完成对象的实例化工作。1、先准备一个基本的容器对象，包含一些map结构的集合，用来方便后续过程中存储具体的对象。
一步步动手实现一个简易的IOC容器
weixin_46120888的博客
12-18 607
手动实现IOC容器
IOC容器简单实现
12-27
一个简单的IOC容器的java实现，一个简单的IOC容器的java实现
模拟Spring的IoC容器实现注解自动装配
05-10
自己实现的简易的模拟Spring的IoC容器，实现注解自动装配
java代码实现简易版IOC容器！.docx
11-22
java代码实现简易版IOC容器！.docx
自主实现的简易Spring框架
05-12
自主实现的简易Spring框架，通过注解实现IoC容器和AOP。
简易的手写springmvc
08-04
本工程模仿了简易的springMVC的实现， 包含了controller、service、requestParam、autowired、requestMapping注解类的创建 IOC容器的创建及组装原理实现 简易的request请求
自己实现的ioc容器
10-13
自己用纯java（未使用任何框架),实现的IOC容器，对理解springIOC的原理有一定的帮助，对spring初学者有一定的帮助
如何实现一个springioc容器
efggfxfvhh的博客
01-31 922
如何实现一个springioc容器
如何实现一个IOC容器?
scdd0071的博客
10-17 1811
什么是IOC? IOC意思控制反转,IOC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制 IOC有专门的容器来进行对象的创建,IOC容器来控制对象的创建 具体步骤: 1.先准备一个容器对象,map结构 2.进行配置文件的读取,或注解的解析操作,将需要创建的bean封装为BeanDefinition对象存储在容器中 3.容器将封装好的beanDefiniotn对象,通过反射进行实例化操作 4.通过di注入给类中的对应属性值进行设置,完成整个对象的创建,变成一个完成的b
Spring的IoC容器实现
我的编程世界
11-13 689
1.BeanFactory 基础类型IoC容器，提供完整的IoC服务支持。如果没有特殊指定，默认采用延时初始 化策略。只有当客户端对象需要访问访问容器中的某个依赖对象时，才对该依赖对象进行 初始化以及依赖注入操作。所以相对来说，容器启动初期速度较快，所需资源有限。对于 资源有限，并且功能要求不是很严格的场景，BeanFactory是比较适合的容器选择。 2.Application
自己实现spring(一) —— ioc容器实现
fanday的博客
07-18 3906
前言:加深对spring的理解,把spring ioc的大致流程抽出来,自己动手撸一个简洁版的 新建一个maven工程,这里使用idea工具 pom文件只依赖一个servlet &amp;amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot;?&amp;amp;gt; &amp;amp;lt;project xmlns=&am
自己动手开发IOC容器
一名系统架构师的征途
07-09 8269
我们广大程序员总是谈论IoC，可是少有人将注意力放在IoC如何实现上，在本文中，我将用简要的语言，配合一些图例，从需求，设计，代码三方面来描述如何实现一个简单的IoC容器。代码也已公布，见我的CSDN CODE，地址：https://code.csdn.net/shan9liang/ioccontainer
SpringIOC容器的实现（简述）
向北
12-13 2155
Spring的IOC和DI实际上说的是同一件事情。 IOC：（Inversion of Control）控制反转，简单的将就是将原始类A使用类B时需要在类A中创建B的操作，交给第三方（容器），将A控制B的权利反转给容器。 DI：（Dependency Injection）依赖注入，控制反转的概念有些不易理解，所以，换一种说法是A使用B，A不自己创建B，而依赖容器类帮他创建并注入到A中。 而S
Spring源码剖析——核心IOC容器原理
热门推荐
拂晓的专栏
08-05 1万+
IOC介绍  相信大多数人在学习Spring时 IOC 和 Bean 算得上是最常听到的两个名词，IOC在学习Spring当中出现频率如此之高必然有其原因。如果我们做一个比喻的话，把Bean说成Spring中主角的话，那么IOC便是这个主角进行演出的舞台,没有IOC作为Bean的承载，那么Bean便不会在编程中大放异彩。作为Spring核心组件的重要一员，了解其内部实现对我们编程和窥探Spring内
实现简易spring ioc容器代码
最新发布
04-07
好的，以下是一个简单的实现代码： ```java public class SimpleIOCContainer { private Map, Object> beanMap = new HashMap();...这是一个非常简单的 IOC 容器实现，实际上真正的 IOC 容器会更加复杂和灵活。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值