ioc容器的实现方法有哪些_Spring（一）: IOC概念，手写IOC

最新推荐文章于 2022-12-08 15:44:01 发布
最新推荐文章于 2022-12-08 15:44:01 发布
阅读量247 收藏
点赞数
文章标签： ioc容器的实现方法有哪些

IOC是什么： 

inversion of control 控制反转

如何反转：

依赖对象的获得被反转了，由自己创建，反转为从IOC容器中获取（和自动注入）

好处：

1.代码更简洁，不需要去new   
2. 面向接口变成，使用者与具体类解耦，易扩展，替换实现者
3.可以方便的进行aop增强，没有IOC就不可以进行aop

IOC容器做什么工作？

负责创建/管理类实例，向使用者提供实例

IOC容器是不是工厂模式的实例？

是的。IOC容器负责创建类实例对象，需要就从IOC容器中get，也称IOC容器为bean工厂

IOC容器的工作就是：创建、管理Bean，是一个工厂，负责对外提供bean实例，bean就是组件，也就是类的对象。

IOC应该具备什么行为呢（对外接口接口）？

对外提供bean实例，getBean（）方法

这个getBean（）方法是否需要参数？需要几个参数，什么样类型的参数？

在简单工厂模式中，当工厂能创建很多类产品的时候，如需要创建某类产品，需要告诉工厂

这个getBean()方法的返回值应该是什么类型的？

因为要返回各种类型的Bean，那就只能是Object了

Bean工厂的接口：

bean工厂创建bean需要有bean定义，后面说bean定义

66fe2af53bbcca7de811b2f56e1956ee.png

现在的问题是Bean工厂怎么知道该如何创建bean？

得把bean定义告诉bean工厂。这个bean是这么创建，那个bean是那么创建

那么如何告诉bean工厂bean定义呢？

因为有很多的bean定义，这个bean，那么bean，
所以就有一个定义注册，可以定义一个定义注册的接口，
把所有的bean定义都注册进来，那么就加一个注册接口

Bean定义注册接口

ae4afdb550fd2dc84ed688ab4607aa7b.png

这个bean定义注册接口中应该定义什么方法？

注册、获取bean定义

注册的bean定义信息如何区分？

每个bean定义有一个唯一的名称

1d418e7e337929d4b5af2fc6ec57da0a.png

上面是bean定义的注册接口，下来是bean定义

e13fcce8c5745e407398682fa9941c5e.png

bean定义的用途是什么？

告诉bean工厂该如何创建某类bean，这个bean这么创建，那个bean那么创建

获得类的实例的方式有哪些（常用的）

new 构造
工厂：静态和成员方法

bean工厂创建bean的时候，需要知道哪些信息？

假如是new 构造创建的话，需要知道类名
假如是静态工厂方法的话，需要知道工厂类名，工厂方法名
假如是成员工厂方法的话，工厂类名？-> 工厂bean名，工厂方法名

每次从bean工厂获取bean实例的时候，是否都需要创建一个新的bean呢？

不需要，因为有的bean只需单实例

bean定义是给bean工厂创建bean用的，那么bean定义接口应该向bean工厂提供哪些方法？

获取bean类名：getBeanClass() :Class
获取工厂方法名：getFactoryMethodName() :String
获取工厂bean名：getFactoryBeanName() :String
是否是单例等方法： getScope() :String   isSingleton()   isPrototype()

类对象交给IOC容器管理，类对象的生命周期中还可能有什么生命阶段事情要做？

比如创建对象后可能需要进行一些初始化
有的对象在销毁时可能要进行一些特定的销毁逻辑（比如释放资源）
那就再bean定义中提供让用户可指定初始化、销毁方法
对bean工厂就需要提供 getInitMethodName()  getDestroyMethodName()

那么就有了下图：

076a868a6742abc766ba4e77685338e1.png

92f2e1d5eda20d8f6a76229e6a1e5260.png

会看到StringUtils的 isBank 方法，来普及一下和 isEmpty() 的区别

StringUtils

想要用的话需要引入依赖：

<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
</dependency>

BeanDefinition（bean定义）接口的java实现：

import org.apache.commons.lang3.StringUtils;

public interface BeanDefinition {
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
    /**
     * 类
     */
    Class<?> getBeanClass();
    /**
     * Scope
     */
    String getScope();
    /**
     * 是否单例
     */
    boolean isSingleton();
    /**
     * 是否原型
     */
    boolean isPrototype();
    /**
     * 工厂bean名
     */
    String getFactoryBeanName();
    /**
     * 工厂方法名
     */
    String getFactoryMethodName();
    /**
     * 初始化方法
     */
    String getInitMethodName();
    /**
     * 销毁方法
     */
    String getDestroyMethodName();
    /**
     * 校验bean定义的合法性
     */
    default boolean validate() {
        // 没定义class,工厂bean或工厂方法没指定，则不合法。
        if (this.getBeanClass() == null) {
            if (StringUtils.isBlank(getFactoryBeanName()) || StringUtils.isBlank(getFactoryMethodName())) {
                return false;
            }
        }
        // 定义了类，又定义工厂bean，不合法
        if (this.getBeanClass() != null && StringUtils.isNotBlank(getFactoryBeanName())) {
            return false;
        }
        return true;
    }
}

BeanDefinition（bean定义）接口的实现类GenericBeanDefinition，通用的bean定义：

import org.apache.commons.lang3.StringUtils;

public class GenericBeanDefinition implements BeanDefinition {
    private Class<?> beanClass;

    private String scope = BeanDefinition.SCOPE_SINGLETON;

    private String factoryBeanName;

    private String factoryMethodName;

    private String initMethodName;

    private String destroyMethodName;

    public void setBeanClass(Class<?> beanClass) {
        this.beanClass = beanClass;
    }

    public void setScope(String scope) {
        if (StringUtils.isNotBlank(scope)) {
            this.scope = scope;
        }
    }

    public void setFactoryBeanName(String factoryBeanName) {
        this.factoryBeanName = factoryBeanName;
    }

    public void setFactoryMethodName(String factoryMethodName) {
        this.factoryMethodName = factoryMethodName;
    }

    public void setInitMethodName(String initMethodName) {
        this.initMethodName = initMethodName;
    }

    public void setDestroyMethodName(String destroyMethodName) {
        this.destroyMethodName = destroyMethodName;
    }

    @Override
    public Class<?> getBeanClass() {
        return this.beanClass;
    }

    @Override
    public String getScope() {
        return this.scope;
    }

    @Override
    public boolean isSingleton() {
        return BeanDefinition.SCOPE_SINGLETON.equals(this.scope);
    }

    @Override
    public boolean isPrototype() {
        return BeanDefinition.SCOPE_PROTOTYPE.equals(this.scope);
    }

    @Override
    public String getFactoryBeanName() {
        return this.factoryBeanName;
    }

    @Override
    public String getFactoryMethodName() {
        return this.factoryMethodName;
    }

    @Override
    public String getInitMethodName() {
        return this.initMethodName;
    }

    @Override
    public String getDestroyMethodName() {
        return this.destroyMethodName;
    }

    @Override
    public String toString() {
        return "GenericBeanDefinition [beanClass=" + beanClass + ", scope=" + scope + ", factoryBeanName="
                + factoryBeanName + ", factoryMethodName=" + factoryMethodName + ", initMethodName=" + initMethodName
                + ", destroyMethodName=" + destroyMethodName + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((beanClass == null) ? 0 : beanClass.hashCode());
        result = prime * result + ((destroyMethodName == null) ? 0 : destroyMethodName.hashCode());
        result = prime * result + ((factoryBeanName == null) ? 0 : factoryBeanName.hashCode());
        result = prime * result + ((factoryMethodName == null) ? 0 : factoryMethodName.hashCode());
        result = prime * result + ((initMethodName == null) ? 0 : initMethodName.hashCode());
        result = prime * result + ((scope == null) ? 0 : scope.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        GenericBeanDefinition other = (GenericBeanDefinition) obj;
        if (beanClass == null) {
            if (other.beanClass != null)
                return false;
        } else if (!beanClass.equals(other.beanClass))
            return false;
        if (destroyMethodName == null) {
            if (other.destroyMethodName != null)
                return false;
        } else if (!destroyMethodName.equals(other.destroyMethodName))
            return false;
        if (factoryBeanName == null) {
            if (other.factoryBeanName != null)
                return false;
        } else if (!factoryBeanName.equals(other.factoryBeanName))
            return false;
        if (factoryMethodName == null) {
            if (other.factoryMethodName != null)
                return false;
        } else if (!factoryMethodName.equals(other.factoryMethodName))
            return false;
        if (initMethodName == null) {
            if (other.initMethodName != null)
                return false;
        } else if (!initMethodName.equals(other.initMethodName))
            return false;
        if (scope == null) {
            if (other.scope != null)
                return false;
        } else if (!scope.equals(other.scope))
            return false;
        return true;
    }
}

看看现在都有什么了：下图是bean定义

a48c4d68b14354c8feac7f62c2f0bd54.png 
下来需要实现 BeanFactory（bean工厂）了。

3949ca0e078a77f73c72b17ba9a76c3d.png 
实现一个默认的bean工厂：DefaultBeanFactory

1bbb90371b199a6dcbda3065b545e092.png 
思考一下：需要实现这两个接口的话，
1、实现BeanDefinitionRegistry（上图右边右边的Bean定义信息注册）
  1.1、bean定义信息如何存放？
        Map，concurrentHashMap
  1.2、bean定义是否可以重名？重名了怎么办？
        自定义吧，想怎么实现就怎么实现,抛异常等等。

2、实现beanFactory（bean工厂）（上图左边）
  2.1、创建bean用什么存放？
        Map、concurrentHashMap
  2.2、在getBean（）中要做哪些事？
        创建bean实例，并进行初始化

现在把BeanFactory这个接口写出：

public interface BeanFactory {
    /**
     * 获取bean
     *
     * @param name
     *            bean的名字
     * @return bean 实例
     * @throws Exception
     */
    Object getBean(String name) throws Exception;

}

再把BeanDefinitionRegistry这个接口写出来：

public class BeanDefinitionRegistException extends Exception {
    private static final long serialVersionUID = 6056374114834139330L;

    public BeanDefinitionRegistException(String mess) {
        super(mess);
    }

    public BeanDefinitionRegistException(String mess, Throwable e) {
        super(mess, e);
    }
}
public interface BeanDefinitionRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegistException;

    BeanDefinition getBeanDefinition(String beanName);

    boolean containsBeanDefinition(String beanName);

}

实现一个默认的bean工厂：DefaultBeanFactory：

import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;



public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable {

    private final Log logger = LogFactory.getLog(getClass());

    // map的key是String,value是BeanDefinition
    private Map<String, BeanDefinition> beanDefintionMap = new ConcurrentHashMap<>(256);
    // 单纯的一个ConcurrentHashMap
    private Map<String, Object> beanMap = new ConcurrentHashMap<>(256);

    // BeanDefinitionRegistry接口里的方法
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegistException {
        Objects.requireNonNull(beanName,"注册bean需要给入beanName");
        Objects.requireNonNull(beanDefinition,"注册bean需要给入beanDefinition(bean定义)");

        // 校验给入的bean是否合法,如果不合法就抛异常
        if(!beanDefinition.validate()){
            throw new BeanDefinitionRegistException("名字为[" + beanName + "] 的bean定义不合法：" + beanDefinition);
        }
        //如果BeanDefinition中已经有了这个bean的定义,也抛异常
        if (this.containsBeanDefinition(beanName)) {
            throw new BeanDefinitionRegistException(
                    "名字为[" + beanName + "] 的bean定义已存在:" + this.getBeanDefinition(beanName));
        }
        //bean是合法的,且BeanDefinition中没有这个bean的定义，把这个beanName,beanDefinition存到Map里
        this.beanDefintionMap.put(beanName, beanDefinition);
    }

    // BeanDefinitionRegistry接口里的方法
    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        // 得到bean定义需要从map里去取，如果能取到那就返回BeanDefinition
        // 如果从map里取不到,则为null
        return this.beanDefintionMap.get(beanName);
    }

    // BeanDefinitionRegistry接口里的方法
    @Override
    public boolean containsBeanDefinition(String beanName) {
        return this.beanDefintionMap.containsKey(beanName);
    }


    // BeanFactory接口中的方法
    @Override
    public Object getBean(String name) throws Exception {
        // 调用doGetBean
        return this.doGetBean(name);
    }

    // 希望只有子类可以用，所以定义为protected，本类自定义的方法
    protected Object doGetBean(String beanName) throws Exception{
        // 如果 beanName 为null 那么抛异常
        Objects.requireNonNull(beanName, "beanName不能为空");
        // 从Map里获取,这个beanMap是一个单纯的map。
        Object instance = beanMap.get(beanName);

        if (instance != null) {
            // 如果 instance != null 就是获取到了instance ,那么就直接返回
            return instance;
        }
        // 如果没有 instance的话，就得取到bean定义,也就是从map里获取
        // 这个getBeanDefinition(beanName);方法返回的就是从map里获取的
        BeanDefinition bd = this.getBeanDefinition(beanName);

        // 如果bean定义为空 那么抛异常
        Objects.requireNonNull(bd, "beanDefinition不能为空");

        // 如果bean定义不为空 那么就获取调用getBeanClass
        // 这个getBeanClass是 接口BeanDefinition中的方法。
        // GenericBeanDefinition是BeanDefinition的实现类，实现类里
        // 这个getBeanClass()方法返回了一个实例字段
        // private Class<?> beanClass;
        Class<?> type = bd.getBeanClass();
        if (type != null) {
            if (StringUtils.isBlank(bd.getFactoryMethodName())) {
                // 构造方法来构造对象
                instance = this.createInstanceByConstructor(bd);
            } else {
                // 静态工厂方法
                instance = this.createInstanceByStaticFactoryMethod(bd);
            }
        } else {
            // 工厂bean方式来构造对象
            instance = this.createInstanceByFactoryBean(bd);
        }

        // 执行初始化方法
        this.doInit(bd, instance);

        if (bd.isSingleton()) {
            beanMap.put(beanName, instance);
        }

        return instance;



    }

    // 构造方法来构造对象
    private Object createInstanceByConstructor(BeanDefinition bd)
            throws InstantiationException, IllegalAccessException {
        try {
            return bd.getBeanClass().newInstance();
        } catch (SecurityException e1) {
            logger.error("创建bean的实例异常,beanDefinition：" + bd, e1);
            throw e1;
        }
    }

    // 静态工厂方法
    private Object createInstanceByStaticFactoryMethod(BeanDefinition bd) throws Exception {
        Class<?> type = bd.getBeanClass();
        Method m = type.getMethod(bd.getFactoryMethodName(), null);
        return m.invoke(type, null);
    }

    // 工厂bean方式来构造对象
    private Object createInstanceByFactoryBean(BeanDefinition bd) throws Exception {

        Object factoryBean = this.doGetBean(bd.getFactoryBeanName());

        Method m = factoryBean.getClass().getMethod(bd.getFactoryMethodName(), null);

        return m.invoke(factoryBean, null);
    }

    /**
     * 执行初始化方法
     *
     * @param bd
     * @param instance
     * @throws Exception
     */
    private void doInit(BeanDefinition bd, Object instance) throws Exception {
        // 执行初始化方法
        if (StringUtils.isNotBlank(bd.getInitMethodName())) {
            Method m = instance.getClass().getMethod(bd.getInitMethodName(), null);
            m.invoke(instance, null);
        }
    }

    @Override
    public void close() throws IOException {
        // 执行单例实例的销毁方法
        for (Entry<String, BeanDefinition> e : this.beanDefintionMap.entrySet()) {
            String beanName = e.getKey();
            BeanDefinition bd = e.getValue();

            if (bd.isSingleton() && StringUtils.isNotBlank(bd.getDestroyMethodName())) {
                Object instance = this.beanMap.get(beanName);
                try {
                    Method m = instance.getClass().getMethod(bd.getDestroyMethodName(), null);
                    m.invoke(instance, null);
                } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
                        | InvocationTargetException e1) {
                    logger.error("执行bean[" + beanName + "] " + bd + " 的 销毁方法异常！", e1);
                }
            }
        }
    }

}

对于单例的bean，可否提前实例化？有什么好处？

可以,好处就是：使用的时候，会快一点，空间换时间，线程安全，

扩展DefaultBeanFactory增加提前实例化单例bean的功能。

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.ArrayList;
import java.util.List;

public class PreBuildBeanFactory extends DefaultBeanFactory {
    private final Log logger = LogFactory.getLog(getClass());

    private List<String> beanNames = new ArrayList<>();

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionRegistException {
        super.registerBeanDefinition(beanName, beanDefinition);
        synchronized (beanNames) {
            beanNames.add(beanName);
        }
    }

    public void preInstantiateSingletons() throws Exception {
        synchronized (beanNames) {
            for (String name : beanNames) {
                BeanDefinition bd = this.getBeanDefinition(name);
                if (bd.isSingleton()) {
                    this.doGetBean(name);
                    if (logger.isDebugEnabled()) {
                        logger.debug("preInstantiate: name=" + name + " " + bd);
                    }
                }
            }
        }
    }
}

接下来就可以测试代码了：

测试准备

public class ABean {
    public void doSomthing() {
        System.out.println(System.currentTimeMillis() + " " + this);
    }

    public void init() {
        System.out.println("ABean.init() 执行了");
    }

    public void destroy() {
        System.out.println("ABean.destroy() 执行了");
    }

}
public class ABeanFactory {
    public static ABean getABean() {
        return new ABean();
    }

    public ABean getABean2() {
        return new ABean();
    }

}

DefaultBeanFactoryTest 测试：

import org.junit.Test;
import org.junit.AfterClass;

public class DefaultBeanFactoryTest {
    static DefaultBeanFactory bf = new DefaultBeanFactory();

    @Test
    public void testRegist() throws Exception {

        // 创建通用的bean定义
        GenericBeanDefinition bd = new GenericBeanDefinition();

        // 把 GenericBeanDefinition中 private Class<?> beanClass;
        // 给一个初始值为 ABean.class
        // private Class<?> beanClass = ABean.class
        bd.setBeanClass(ABean.class);
        bd.setScope(BeanDefinition.SCOPE_SINGLETON);
        // bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);

        bd.setInitMethodName("init");
        bd.setDestroyMethodName("destroy");

        // 把bd注册到bean工厂中
        // registerBeanDefinition 是BeanDefinitionRegistry接口里的方法
        // DefaultBeanFactory 实现了 BeanFactory, BeanDefinitionRegistry, Closeable 接口
        bf.registerBeanDefinition("aBean", bd);

    }

    @Test
    public void testRegistStaticFactoryMethod() throws Exception {
        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABeanFactory.class);
        bd.setFactoryMethodName("getABean");
        bf.registerBeanDefinition("staticAbean", bd);
    }

    @Test
    public void testRegistFactoryMethod() throws Exception {
        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(ABeanFactory.class);
        String fbname = "factory";
        bf.registerBeanDefinition(fbname, bd);

        bd = new GenericBeanDefinition();
        bd.setFactoryBeanName(fbname);
        bd.setFactoryMethodName("getABean2");
        bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);

        bf.registerBeanDefinition("factoryAbean", bd);
    }

    @AfterClass
    public static void testGetBean() throws Exception {
        System.out.println("构造方法方式------------");
        for (int i = 0; i < 3; i++) {
            ABean ab = (ABean) bf.getBean("aBean");
            ab.doSomthing();
        }

        System.out.println("静态工厂方法方式------------");
        for (int i = 0; i < 3; i++) {
            ABean ab = (ABean) bf.getBean("staticAbean");
            ab.doSomthing();
        }

        System.out.println("工厂方法方式------------");
        for (int i = 0; i < 3; i++) {
            ABean ab = (ABean) bf.getBean("factoryAbean");
            ab.doSomthing();
        }

        bf.close();
    }
}

运行结果：

构造方法方式------------
ABean.init() 执行了
1587625018827 com.spring.test.ABean@1eb44e46
1587625018827 com.spring.test.ABean@1eb44e46
1587625018827 com.spring.test.ABean@1eb44e46
静态工厂方法方式------------
1587625018827 com.spring.test.ABean@515f550a
1587625018827 com.spring.test.ABean@515f550a
1587625018827 com.spring.test.ABean@515f550a
工厂方法方式------------
1587625018827 com.spring.test.ABean@626b2d4a
1587625018827 com.spring.test.ABean@5e91993f
1587625018827 com.spring.test.ABean@1c4af82c
ABean.destroy() 执行了

Process finished with exit code 0
weixin_39816027
关注
Spring IOC的基本概念，IoC容器的实现方式有哪些？
javamyfriend的博客
06-14 385
Spring IOC的基本概念，IoC容器的实现方式有哪些？
手写一个SpringIoc容器
04-12
本项目"手写一个SpringIoc容器"旨在模仿Spring的IOC（Inversion of Control，控制反转）功能，帮助开发者深入理解Spring的工作原理，提升对依赖注入（Dependency Injection）模式的认识。 在实现自定义的Spring IOC...
ioc容器的实现方法有哪些_自己动手实现一个简单的 IOC容器
weixin_39593744的博客
12-01 482
控制反转,即Inversion of Control（IoC），是面向对象中的一种设计原则，拉勾IT课小编分解可以用有效降低架构代码的耦合度，从对象调用者角度又叫做依赖注入，即Dependency Injection（DI），通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的容器，将其所依赖的对象的引用传递给它，也可以说，依赖被注入到对象中，这个容器就是我们经常说到IOC容器。Sping...
长文预警！Spring源码之IoC容器的基本实现
qwe123147369的博客
11-03 286
Spring源码之容器的基本实现 概述 Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。 本文以Spring 5.1.X版本为前提 Spring的结构组成 Spring框架是一个分层架构，它包含一系列的功能要素，并被分为大约20个
ioc容器的实现方法有哪些_面试问到IOC我该如何回答呢？
weixin_39932458的博客
12-01 171
前言  相信在面试中，只要问到Spring，基本都会抛出一个问题，说说你对Spring IOC理解吧？虽然在日常的开发经常会使用到，但是要回答起来，并不简单。大脑经过简单的头脑风暴后，蹦出了控制反转、依赖注入这样的词语。显然这些并不是面试官想听的。IOC是什么？  IOC(Inverse of Contro)控制反转，有时候也被称为DI(Dependency injection)依赖注入，它是一种...
卧槽！原来 IOC 这么简单
公众号：Java后端
05-20 333
抛开Spring去理解IOC思想 - 原来IOC容器这么简单很多小伙伴们看到这句话可能就会想到抛开Spring就不会存在IOC思想了，其实不然在接下来的文章中就会讲述到。很多小伙伴在理解...
手写SpringIOC注解实现版本
01-25
这个"手写Spring IOC注解实现版本"项目旨在帮助我们深入理解Spring框架的工作原理，通过实际动手实现来增强对IoC容器和注解驱动编程的理解。 在Spring中，IOC意味着应用程序不再直接创建对象，而是将对象的创建和...
手写SpringIoc的XML实现方式
01-24
在本主题中，我们将深入探讨如何手写一个基于XML的Spring IOC实现，模仿Spring框架中的`ClassPathXmlApplicationContext`。这个实现旨在帮助理解Spring底层的工作原理，并加深对IoC容器的理解。 首先，我们需要创建...
手写spring ioc(三) 资源org.zip
12-13
在本资源"手写spring ioc(三) 资源org.zip"中，我们主要关注的是如何实现一个简易版的Spring IOC（Inversion of Control）容器，它涵盖了ioc的基本功能，包括解决循环依赖、使用构造器注入以及自动注入等核心特性。...
【框架源码篇 01】Spring源码-手写IOC
最新发布
10-21
在本系列的第一篇【框架源码篇 01】中，我们...在01-手写IoC源码-spring-v1.zip文件中，你将找到逐步实现这个过程的代码示例，这将帮助你加深对Spring IOC的理解。记得阅读和研究这些代码，实践是检验理论的最好方式。
Ioc的两种实现方式
03-22
NULL 博文链接：https://jackroomage.iteye.com/blog/1010510
ioc容器的实现方法有哪些_spring--ioc详细介绍
weixin_39792751的博客
11-28 623
spring主要学习AOP和IOC概念IOC :inverse of control 控制反转或者依赖注入控制反转：从主动实例化对象，转换到被动获取对象(spring用的反射技术实现)依赖注入：需要什么对象，容器就注入什么对象ioc主要是用来实现对象装配的，比如controller调用service,controller中的service对象要来自容器，也就是容器要把service对象装配到con...
Spring升级案例之IOC介绍和依赖注入
weixin_42364196的博客
07-14 182
Spring升级案例之IOC介绍和依赖注入 一、IOC的概念和作用 1.什么是IOC 控制反转(Inversion of Control, IoC)是一种设计思想，在Java中就是将设计好的对象交给容器控制，而不是传统的在对象内部直接控制。传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；可以理解为IoC 容器控制了对象和外部资源获取（不只是对象包括比如文件等）。 2.反转和正转 有反转就有
ioc容器的实现方法有哪些_Spring框架IOC容器实现原理
weixin_39777019的博客
12-01 203
在上一篇中我们通过spring的IOC容器，成功实例化了我们指定的对象，在这一篇中我们将简单了解一下spring底层到底是怎么实现上述功能呢。也就是Java中反射技术。由于反射技术是Java API中提供的功能，所以在这里我们不在做过多的介绍，而是通过测试用例，来了解一下反射技术的具体应用。下面我们将用反射技术，来实现上一篇中IOC容器实现的功能。属性注入构造函数注入接口注入上面的代码基本实现了我...
用简单代码实现IOC容器
3y
03-26 841
本文作者：加耀 投稿手写IOC容器了解一下！相信每一个java程序员在面试经历中，都被面试官问到过AOP和IOC，用官方的话语来回答AOP和IO...
面试被问了几百遍的 IoC 和 AOP ，还在傻傻搞不清楚？
singwhatiwanna
05-17 4176
本文为读者投稿，原文地址：https://gyl-coder.top/spring/spring-ioc-aop/。这篇文章会从下面从以下几个问题展开对 IoC & AOP 的...
面试题：自己实现一个简单的IOC容器
qq_42820805的博客
09-25 906
前言文本已收录至我的GitHub仓库，欢迎Star：https://github.com/bin392328206/six-finger种一棵树最好的时间是十年前，其次是现在欢迎加入六脉...
什么是Spring IOC 容器？
yqhp_w
12-18 8002
Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。
IOC 容器
FairyKunKun的博客
12-08 1153
控制饭庄（ Inversion of Control ，缩写为 IOC），是面向对象编程中的一种设计原则，可以用来降低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，有一个调控系统内所有对象的外接实体将其所依赖的对象的引用传递给它。（2） ApplicationContext： BeanFactory 接口的子接口，提供更多强大的功能，一般是由开发人员进行使用的。（1） BeanFactory ： IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用。
Spring源码解析：手写IoC理解与实现
本文档深入探讨了Spring框架中的IoC（Inversion of Control）概念及其手写实现。首先，Spring的核心包括IoC和AOP（Aspect-Oriented Programming，面向切面编程），两者共同构成了Spring架构的基础。IoC的核心思想是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值