谈一谈Spring IOC

最新推荐文章于 2025-04-11 20:26:35 发布
最新推荐文章于 2025-04-11 20:26:35 发布
阅读量149 收藏
点赞数
分类专栏： 技术人生 文章标签： spring java ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sswltt/article/details/105918814
版权

概念

IOC：Inversion of comtrol 控制反转，这个概念说起来很熟悉，理解起来还是有点困难的。要先弄清楚第一个问题：谁控制了谁？

public class Persion {
    private Order order;
    public Persion(Order order) {
        
        this.order = order;
    }
}

Persion 持有Order 的引用，在创建Persion的时候一定要有Order的对象传入才可以，这就是Order 控制着Persion.
现在要将这个控制权交给Persion，怎么做到的呢？IOC来管理所有的对象，Persion需要什么跟IOC要就可以，怎么要呢，通过依赖注入来要。
DI:Dependecy inversion 依赖注入，IOC是更加抽象的一层含义，可以只理解成一种思想，通过容器来控制对象的思想，真是的实现手段就是DI;
DI的三种实现方式：
接口注入：对代码有入侵不推荐
注解注入：@Autowired根据类型注入 @Resource 根据名称注入
setter注入：通过setter方法注入

容器启动流程

这个流程只是一个大概的流程方便我们更好的理解IOC
在这里插入图片描述

重要类的源码解析

AbstractApplicationContext的refresh()定义了整个spring启动的流程，有关bean的几个重要的步骤做了解释。

在这里插入图片描述跟踪 obtainFreshBeanFactory（）
AbstractRefreshableApplicationContext
在这里插入图片描述
loadBeanDefinitions()这个方法中做的事情
如果是读取XML文件中的bean就会用到XmlBeanDefinitionReader 将xml文件的内容解析成BeanDefinition
如果是扫描注解创建bean 就会用到AnnotatedBeanDefinitionReader将扫描到的class文件 通过类的加载器加载到容器种转化成BeanDefinition
最后BeanDefinition保存在
在这里插入图片描述
接下来我们分析一下这个方法
this.finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //先初始化ConversionService类型的bean  ConversionService这个是前端向controller传递参数的时候需要特殊处理的时候用的
    //例如时间字符串 勇敢date接受
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }
    //初始化LoadTimeWeaverAware类型的bean
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader((ClassLoader)null);
    beanFactory.freezeConfiguration();
    // 预初始化 继续跟踪这个方法
    beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory


public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Pre-instantiating singletons in " + this);
    }
    // 循环遍历所有非懒加载的beanDefinition
    List<String> beanNames = new ArrayList(this.beanDefinitionNames);
    Iterator var2 = beanNames.iterator();

    while(true) {
        String beanName;
        Object bean;
        do {
            while(true) {
                RootBeanDefinition bd;
                do {
                    do {
                        do {
                            if (!var2.hasNext()) {
                                var2 = beanNames.iterator();

                                while(var2.hasNext()) {
                                    beanName = (String)var2.next();
                                    //如果已初始化完成这一步就可以直接获取到
                                    Object singletonInstance = this.getSingleton(beanName);
                                    // 如果是这个SmartInitializingSingleton类型的就在这里回调
                                    if (singletonInstance instanceof SmartInitializingSingleton) {
                                        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                        if (System.getSecurityManager() != null) {
                                            AccessController.doPrivileged(() -> {
                                                smartSingleton.afterSingletonsInstantiated();
                                                return null;
                                            }, this.getAccessControlContext());
                                        } else {
                                            smartSingleton.afterSingletonsInstantiated();
                                        }
                                    }
                                }

                                return;
                            }

                            beanName = (String)var2.next();
                            bd = this.getMergedLocalBeanDefinition(beanName);
                        } while(bd.isAbstract());
                    } while(!bd.isSingleton());
                } while(bd.isLazyInit());
            // 如果是FactoryBean在beanName 前加 &
                if (this.isFactoryBean(beanName)) {
                    bean = this.getBean("&" + beanName);
                    break;
                }

                this.getBean(beanName);
            }
        } while(!(bean instanceof FactoryBean));

        FactoryBean<?> factory = (FactoryBean)bean;
        boolean isEagerInit;
        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
            SmartFactoryBean var10000 = (SmartFactoryBean)factory;
            ((SmartFactoryBean)factory).getClass();
            isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
        } else {
            isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
        }

        if (isEagerInit) {
            this.getBean(beanName);
        }
    }
}

这个方法中我们可以看到在初始化bean的时候factoryBean是要特殊处理的跟普通的Bean不一样。简单的Bean会通过getBean这个方法初始化，继续看这个方法

AbstractBeanFactory

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);
    Object bean;
    if (sharedInstance != null && args == null) {
        if (this.logger.isTraceEnabled()) {
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
            } else {
                this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }

        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
    } else {
        if (this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
            String nameToLookup = this.originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
            }

            if (args != null) {
                return parentBeanFactory.getBean(nameToLookup, args);
            }

            if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

            return parentBeanFactory.getBean(nameToLookup);
        }

        if (!typeCheckOnly) {
            this.markBeanAsCreated(beanName);
        }

        try {
            RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            this.checkMergedBeanDefinition(mbd, beanName, args);
            String[] dependsOn = mbd.getDependsOn();
            String[] var11;
            if (dependsOn != null) {
                var11 = dependsOn;
                int var12 = dependsOn.length;

                for(int var13 = 0; var13 < var12; ++var13) {
                    String dep = var11[var13];
                    if (this.isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }

                    this.registerDependentBean(dep, beanName);

                    try {
                        this.getBean(dep);
                    } catch (NoSuchBeanDefinitionException var24) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                    }
                }
            }

            if (mbd.isSingleton()) {
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                        return this.createBean(beanName, mbd, args);
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                var11 = null;

                Object prototypeInstance;
                try {
                    this.beforePrototypeCreation(beanName);
                    prototypeInstance = this.createBean(beanName, mbd, args);
                } finally {
                    this.afterPrototypeCreation(beanName);
                }

                bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                String scopeName = mbd.getScope();
                Scope scope = (Scope)this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }

                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        this.beforePrototypeCreation(beanName);

                        Object var4;
                        try {
                            var4 = this.createBean(beanName, mbd, args);
                        } finally {
                            this.afterPrototypeCreation(beanName);
                        }

                        return var4;
                    });
                    bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException var23) {
                    throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                }
            }
        } catch (BeansException var26) {
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var26;
        }
    }

    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            } else {
                return convertedBean;
            }
        } catch (TypeMismatchException var25) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
            }

            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    } else {
        return bean;
    }
}

到这里总的来说我们就分析完了，下面再总结一下

BeanFactory FactoryBean ApplicationContext

BeanFactory ：是spring 框架的根基，是面向spring研发人员的，他的getBean发放是懒加载
功能：1.提供IOC的配置机制。
2. 包含bean的各种定义，便于实例化Bean
3. 建立bean之间的各种依赖关系
4. bean生命周期的管理
FactoryBean：是一个特殊的Bean，（在初始化的时候与普通的bean不一样），内部构造复杂的Bean,是一个工厂bean.
ApplicationContext ：是面向spring使用者的。继承多个接口的高级容器，大多数功能的实现依赖的是DefaultListableBeanFactory这个类。

Bean的生命周期:

如果不是由spring;来管理的话我们的对象new->destory很简单.但是由spring来管理bean以后,bean的创建过程就比较复杂了,生命周期其实就是创建和销毁的过程.

  1. 从XML或者@中扫描到对象,通过BeanDefinitionReader读取bean的信息,加载,注册beanDefinition
  2. 注入Aware的依赖 实现这几个接口 BeanNameAware, BeanFactoryAware,
    ApplicationContextAware,
  3. 实现接口InitializingBean重写方法afterPropertiesSet()
  4. 执行通用的前置方法. 实现BeanPostProcessor接口的postProcessBeforeInitialization()方法.
  5. 通过注解执行init方法@Bean(initMethod = “init”),通过注解构造方法之后执行@PostConstruct
  6. 执行方法BeanPostProcessor.postProcessorAfterInitialization()
  7. 对象创建完毕
    对象的销毁
  8. 执行 DisposableBean.destory() 方法
  9. 执行自定义的destory方法或者 @PreDestory 标注的方法；
  10. 对象销毁完毕
    这些过程大家都可以手动试一下,验证一下的
public class MessageServiceImpl implements MessageService, BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean, BeanFactoryPostProcessor, BeanPostProcessor {
    public void say() {
        System.out.println("hello");
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("MessageServiceImpl setBeanFactory");
    }

    public void setBeanName(String s) {
        System.out.println("MessageServiceImpl setBeanName"+s);
    }

    public void destroy() throws Exception {
        System.out.println("MessageServiceImpl destroy");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("MessageServiceImpl afterPropertiesSet");
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("MessageServiceImpl setApplicationContext");
    }


    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("postProcessBeanFactory====");
    }

    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization");
        return null;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessAfterInitialization");
        return null;
    }
}

Bean的作用域

在这里插入图片描述

Spring5.0源码学习系列之浅谈循环依赖问题（八）
Nicky's blog
11-22 2811
所谓的循环依赖就是指两个及以上的类互相调用依赖，形成闭环，Spring框架检测到这种场景会抛 BeanCurrentlyInCreationException，提前暴露对象的方法
第三章 Spring bean多实例与动态代理笔记
hankin的博客
01-09 1545
一、Bean的多例作用域 1、多实例bean的初始化 1）多实例bean在每次获取bean的时候都会触发getBean操作，因此每次获取都是创建了一个新的对象返回，不论是多线程获取或者是同一个线程获取两次，都是返回一个新的实例对象。 2）多例模式情况，如果出现循环依赖，会直接报错 org.springframework.beans.factory.support.AbstractBeanF...
Spring源码解读
电商技术进阶
04-12 221
前提摘要：关于IDEA如何导入Spring源码，请参考如下链接。 笔者使用的Spring版本：5.1.x。 Windows系统参考：https://blog.csdn.net/hqbootstrap1/article/details/85942897 Mac系统参考：https://www.jianshu.com/p/766580eb8df9 一、Spring Bean的加载过程 （1）实例化S...
spring学习（四）——Bean的加载（scope 的 Bean 创建）
大风的博客
03-15 235
参考文章： http://www.iocoder.cn 根据之前的代码bean类的创建被分为三种方式 singleton ：mbd.isSingleton() prototype：mbd.isPrototype() 其他 singleton 其逻辑代码为 if (mbd.isSingleton()) { //单例模式 sharedInstance = getSin...
Spring注解驱动笔记（一） - 雷丰阳源码级讲解
qq_38973118的博客
09-28 1260
Spring注解驱动开发（一） 简介-注解驱动开发 组件注册-@Configuration&@Bean给容器中注册组件 组件注册-@ComponentScan-自动扫描组件&指定扫描规则 组件注册-自定义TypeFilter指定过滤规则 [组件注册-@Scope-设置组件作用域](# 组件注册-@Scope-设置组件作用域) B站视频地址：https://www.bilibili.com/video/BV1gW411W7wy 简介-注解驱动开发 当我们还在使用Spring、SpringMV
Spring 是解析配置类过程详解
勇往直前的专栏
07-08 531
Spring执行流程图如下： Spring执行流程图这个流程图会随着我们的学习不断的变得越来越详细，也会越来越复杂，希望在这个过程中我们都能朝着精通Spring的目标不断前进！  在上篇文章我们学习了Spring中的第一行代码，我们已经知道了Spring中的第一行代码其实就是创建了一个AnnotatedBeanDefinitionReader对象，这个对象的主要作用就是注册bd（BeanDefinition）到容器中。并且在创建这个对象的过程中，Spring还为容器注册了开天辟地的几个bd，包括Con
浅谈Spring IoC容器
tang_seven的博客
02-03 679
浅谈Spring IoC容器，底层实现过程，及其具体实现依赖注入的两种常见方式
浅谈 Spring IOC和AOP
eugene03的博客
10-19 697
浅谈 Spring IOC和AOP
浅谈 Spring IOC
XiaoMing学习分享博文
09-19 117
Spring IOC 以下内容来自英语未过四级的官网翻译结果，酌情取舍 官网地址 IOC IOC （Inversion of control）控制反转,它也叫依赖注入，它是对象或者引用的对象，只通过构造方法、工厂方法、配置文件，在构造或者工厂方法之后，来设置对象实例。当创建 bean 对象时，容器会注入这些依赖，这个过程从根本上反转，因此叫控制反转；因为它通过直接构造方法或者一种服务定位模式的机制来控制 bean 自身的实例化和依赖的位置。 org.springframework.beans和 org.sp
浅谈Spring IoC容器的依赖注入原理
08-27
浅谈Spring IoC容器的依赖注入原理 Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 ...
浅谈springioc实例化bean的三个方法
08-29
浅谈Spring IOC实例化Bean的三个方法 Spring IOC（Inversion of Control，控制反转）是Spring Framework中的一种核心机制，用于管理Bean的生命周期。实例化Bean是IOC的核心步骤之一，本文将详细讲解Spring IOC实例...
谈一谈你对spring ioc和aop的理解
04-25
好的，关于 Spring IOC 和 AOP 的理解，简单来说，Spring IOC 是一种依赖注入的机制，它可以让组件之间的依赖关系松耦合，以实现更好的可重用性和可维护性。例如，如果一个对象需要使用另一个对象的某个属性或方法，...
Spring两大核心思想：IOC和AOP
m0_73381672的博客
02-19 2289
1.先自定义一个注解@Target(ElementType.METHOD) //作用范围 此处是方法@Retention(RetentionPolicy.RUNTIME) //生命周期 此处是运行时2.在切点表达式中加入该注解@Aspect@Component@Slf4j@Around("@annotation(com.example.demo.aspect.TestAnnotation)") //此处加自定义注解log.info("around继续");try {
Spring其它知识点
m0_45253972的博客
04-10 443
Spring默认的Bean作用域是单例，多个线程同时操作同一个Bean实例。若Bean包含可变成员变量，可能引发线程安全问题。
SpringBoot 项目标准目录结构规范&分层架构和对象分类
m0_63949203的博客
04-09 619
SpringBoot 项目标准目录结构规范&分层架构和对象分类
spring mvc中不同服务调用类型（声明式（Feign）、基于模板（RestTemplate）、基于 SDK、消息队列、gRPC）对比详解
爱的叹息的专栏
04-09 816
spring mvc中不同服务调用类型（声明式（Feign）、基于模板（RestTemplate）、基于 SDK、消息队列、gRPC）对比详解
SpringBoot+Mybatis-Plus实现增删改查
m0_74333250的博客
04-11 948
SpringBoot+Mybatis-Plus实现增删改查
基于SpringBoot的智慧社区管理系统（源码+数据库）
最新发布
shaoweijava的博客
04-11 364
基于SpringBoot的智慧社区管理系统，系统包含三种角色：管理员、用户
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值