Spring-IoC

Eddy咸鱼

已于 2024-04-04 11:50:01 修改

阅读量880

点赞数 28

文章标签： spring java

于 2024-04-04 11:31:43 首次发布

本文链接：https://blog.csdn.net/ljty_ljty/article/details/137300347

版权

概述

What is IoC
Inversion of Control
Why IoC
- 业务层尽量不承担bean的管理工作
Dependency Inversion Principle
- 依赖倒置原则
- 高层不依赖于底层，均依赖抽象
- 实现基础：Java语言对接口，多态的支持；工厂模式
依赖抽象的例子

@Resource
AService aService;

public void doSomething() {
    aService.doSomenthing();
}

IoC与DI的关系
- DI是IoC的一种实现
  - Dependency Injection：依赖注入
  - Dependency Lookup：依赖查找
    - 场景：JNDI
什么是依赖查找

@Stateless  
@EJB(name="audit", beanInterface=AuditService.class)  
public class DepartmentServiceBean implements DepartmentService {  
    private AuditService audit;  
      
    @PostConstruct  
    public void init() {
        try {
            Context ctx = new InitialContext();
            audit = (AuditService) ctx.lookup("java:comp/env/audit");
        } catch (NamingException e) {
            throw new EJBException(e);
        }
    }
  
    public void performAudit() {
        audit.audit();
    }
}

BeanFactory

例1
- 别名map：bean111 -> bean11 -> bean1

<bean id="bean1" class="com.fjh.bean.Bean1" name="bean11"/>
<alias name="bean11" alias="bean111"/>

例2
- 别名map：bean111 -> bean2

<bean id="bean1" class="com.fjh.bean.Bean1" name="bean11"/>
<alias name="bean11" alias="bean111"/>

<bean id="bean2" class="com.fjh.bean.Bean2"/>
<alias name="bean2" alias="bean111"/>

例3
- 别名map：bean111 -> bean11 -> bean2

<bean id="bean1" class="com.fjh.bean.Bean1" name="bean11" />
<alias name="bean11" alias="bean111"/>

<bean id="bean2" class="com.fjh.bean.Bean2"/>
<alias name="bean2" alias="bean11"/>

例4
- 别名map：bean111 -> bean2

<bean id="bean1" class="com.fjh.bean.Bean1" name="bean11"/>
<alias name="bean11" alias="bean111"/>

<bean id="bean2" class="com.fjh.bean.Bean2" name="bean111"/>

例5
- 容器启动失败
- 原因：bean的id和name属性会被缓存，做冲突检测

<bean id="bean1" class="com.fjh.bean.Bean1" name="bean11"/>

<bean id="bean2" class="com.fjh.bean.Bean2" name="bean11"/>

ApplicationContext

spring-002.jpg

附加功能
- EnvironmentCapable
- MessageSource：支持信息源，实现国际化
- ApplicationEventPublisher：事件分发
- ResourcePatternResolver：访问资源

IoC容器初始化

步骤
- Resource定位
- Document载入
- BeanDefinition注册

XmlBeanFactory

Deprecated

ClassPathResource resource = new ClassPathResource("spring-test.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(resource);
System.out.println(factory.getBean("bean1"));

ClassPathXmlApplicationContext

入口

ClassPathXmlApplicationContext构造方法
- super(parent)
  - CPXAC.resourcePatternResolver.resourceLoader = CPXAC
  - CPXAC.parentApplicationContext = parent
- CPXAC.setConfigLocations(configLocations)
- CPXAC.refresh()

Resource定位

ClassPathXmlApplicationContext context1 = new ClassPathXmlApplicationContext("classpath:spring-test.xml");
ClassPathResource("spring-test.xml", Launcher$AppClassLoader)

ClassPathXmlApplicationContext context2 = new ClassPathXmlApplicationContext("spring-test.xml");
ClassPathContextResource("spring-test.xml", Launcher$AppClassLoader)

FileSystemXmlApplicationContext context3 = new FileSystemXmlApplicationContext("spring-test.xml");
FileSystemResource("spring-test.xml") -> FileNotFoundException
需要"D:/spring-test.xml"
或者"classpath:spring-test.xml" -> ClassPathResource("spring-test.xml", Launcher$AppClassLoader)

ClassPathXmlApplicationContext context1 = new ClassPathXmlApplicationContext("classpath*:spring-test.xml");
UrlResource("file:/D:/work/code/jvtest/target/classes/spring-test.xml")
UrlResource("file:/D:/work/code/jvtest/target/test-classes/spring-test.xml")
多个

Document载入

InputStream inputStream = encodedResource.getResource().getInputStream()
InputSource inputSource = new InputSource(inputStream)
doLoadBeanDefinitions(inputSource, encodedResource.getResource());
// 载入 - 得到Document对象,用的org.w3c.dom
Document doc = doLoadDocument(inputSource, resource)

BeanDefinition注册

registerBeanDefinitions(doc, resource)

preProcessXml(root); // 自定义，默认空实现
parseBeanDefinitions(root, this.delegate)
postProcessXml(root); // 自定义，默认空实现

spring-003.jpg

parseBeanDefinitions(root, this.delegate)

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:envDev/config-dev.properties"/>

    <!--<context:annotation-config/>-->

    <context:component-scan base-package="com.fjh"/>

    <bean id="bean1" class="com.fjh.bean.Bean1" name="bean11" />
    
    <alias name="bean11" alias="bean111" />

    <import resource="classpath*:ds.xml"/>

</beans>

beans
- namespaceURI="http://www.springframework.org/schema/beans"
- name="beans"
- localName="beans"
context:property-placeholder
- namespaceURI="http://www.springframework.org/schema/context"
- name="context:property-placeholder"
- localName="property-placeholder"

beans:root
data:"\n\n    "
context:property-placeholder
data:"\n\n    "
data:<context:annotation-config/>
data:"\n\n    "
context:component-scan
...

parseDefaultElement - beans

bean
- 得到BeanDefinitionHolder
  - GenericBeanDefinition beanDefinition
    - beanClass
  - String beanName：id（不存在时用aliases首元素）
  - String[] aliases：name
- 塞入DLBF.Map<beanName, BeanDefinition>
- 塞入DLBF.Map<alias, beanName>
beans
- 递归调用doRegisterBeanDefinitions
import
- 递归加载xml
alias
- 塞入DLBF.Map<alias, name>

parseCustomElement

拿到节点的名空间，比如context
- String namespaceUri = getNamespaceURI(ele)
找hander，怎么找呢
- 加载所有META-INF/spring.handlers形成一个map
- DefaultNamespaceHandlerResolver.resolve(namespaceUri)
META-INF/spring.handlers

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler

ContextNamespaceHandler.init()
找到parser

registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());

AnnotationConfigBeanDefinitionParser

注册6个BeanPostProcessor，功能被component-scan包含

ComponentScanBeanDefinitionParser

doScan(basePackages)得到Set<ScannedGenericBeanDefinition>
默认属性：lazyInit，initMethod，destroyMethod
注解属性：Lazy，Primary，DependsOn，Role，Description
塞到DLBF的map
BeanPostProcessor的role=2
注册6个BeanPostProcessor

问答

classpath*:与classpath:区别

resource1.jar的'com.test.rs'包有一个'jarAppContext.xml'文件

<bean id="processorImplA" class="com.test.spring.di.ProcessorImplA" />

resource2.jar的 'com.test.rs'包也有一个'jarAppcontext.xml'文件

<bean id="processorImplB" class="com.test.spring.di.ProcessorImplB" />

// 可以把两个xml都加载进来
ApplicationContext context = new ClassPathXmlApplicationContext( "classpath*:com/test/rs/jarAppcontext.xml");
// 只会加载第一个xml
ApplicationContext context = new ClassPathXmlApplicationContext( "classpath:com/test/rs/jarAppcontext.xml");

base-package属性中的包在多个jar中出现

根据类加载器规则，同名类只会加载第一次

对于Bean依赖链，有没有做优化？

粗看下，并没有，不会特意优先加载没有需注入属性的bean

IoC依赖注入流程

预实例化，或者手动getBean，都会进入下述流程
AbstractBeanFactory.getBean(String name)
AbstractBeanFactory.doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
- 先看cache：Object sharedInstance = getSingleton(beanName)，第一次嘛，自然是null
- 在parent存在，并且自己的beanDefinitionMap不含该beanName时，才让parent来getBean
- 把beanName塞进Set<String> alreadyCreated
根据beanName拿到RootBeanDefinition
- RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName)，这里也有一个缓存
利用RootBeanDefinition拿到依赖数组
- String[] dependsOn = mbd.getDependsOn()
- 这个和属性注入无关，查看@DependsOn
根据单例，prototype，自定义scope进行处理
利用反射，通过无参构造函数实例化
populateBean
- 属性注入
initializeBean

问答

如何保证单例

DefaultSingletonBeanRegistry.getSingleton方法中，以singletonObjects作为同步块，并有double check

IoC循环依赖

getBean的粗略分步

三个步骤
- createBeanInstance：实例化
- populateBean：依赖处理
- initializeBean：初始化

处理方式

非构造器
- 在缓存那个地方，有三级缓存架构
  - 一级缓存：singletonObjects
  - 二级缓存：earlySingletonObjects
  - 三级缓存：singletonFactories
- 在postProcessMergedBeanDefinition之后，populateBean之前，有一个操作DefaultSingletonBeanRegistry.addSingletonFactory，也就是说加入三级缓存
- 案例：Bean1依赖Bean2，Bean2依赖Bean1；先获取Bean1
- Bean1在三个缓存中都找不到，创建Bean1，加入三级缓存；populateBean的时候，依赖Bean2，所以先去获取Bean2
- Bean2在三个缓存中都找不到，创建Bean2，加入三级缓存；populateBean的时候，依赖Bean1，所以又去获取Bean1
- 首先，一级缓存中没有，isSingletonCurrentlyInCreation为true，进入同步块（这儿采用一级缓存作为同步对象）
- 然后在二级缓存中查找下Bean1，也没有
- allowEarlyReference，这个变量什么情况下会变成false？？？
- 查找三级缓存，找到了singletonFactory（AbstractAutowireCapableBeanFactory），调用singletonFactory.getObject，得到了不完整的Bean1，加入二级缓存，从三级缓存中移除
- 那么这个时候，Bean2的依赖注入就可以完成了，虽然里面的Bean1是个不完整的；Bean2先走完getBean
- 回到Bean1的populateBean中，Bean1的getBean也走完了
- 这个时候：一级缓存有Bean1和Bean2；二级缓存没有，二级缓存中是什么时候被移除的呢
- AbstractBeanfactory的mbd.isSingleton()下面的getSingleton(beanName, new ObjectFactory<Object>()那里
构造器
- Bean1在构造器中依赖Bean2，Bean2也在构造器中依赖Bean1，跪
- Bean1在构造器中依赖Bean2，Bean2在属性依赖Bean1，不会有问题的
  - Bean1在获取构造器参数的时候，会去调用getBean（Bean2），原理上和populateBean是一致的，只是时间点有区别，在createBeanInstance里面