【Spring底层分析】Spring IoC-EW帮帮网

Spring IoC

IoC：控制反转。将对象创建和对象之间的调用交给Spring容器来管理。好处是降低了对象之间的耦合度。

DI：依赖注入。给bean对象注入依赖的对象。

大白话就是：Spring帮你创建对象，对象的属性如果依赖于某个对象，也是Spring为对象注入依赖对象。

怎么理解Spring IoC可以降低对象之间的耦合度？

// 传统高耦合代码
public class UserService {
    private UserRepository userRepository = new JdbcUserRepository(); // 直接依赖具体类

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

Spring IoC降低对象之间的耦合度：

public class UserService {
    private UserRepository userRepository; // 依赖接口

    // 构造器注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository(); // 只需修改此处即可切换实现
    }
}

Spring依赖注入的四个方式？

构造函数注入
- Spring在创建某个类的实例时，会选择这个类的一个构造器创建。
- 如果只有一个构造器就会默认使用，而如果有多个，则选择标有@Autowired注解的构造器使用。
- 解析构造函数参数，从容器获取相应的Bean。
- 创建实例，并完成依赖注入。
字段注入
- Spring创建完类实例后，扫描 @Autowired 注解的字段，Spring 会从容器中找到匹配的 Bean并注入。
setter方法注入
- Spring创建完类实例后，扫描 @Autowired 注解的方法，从容器中找到匹配的 Bean，并通过反射调用 Setter 方法注入依赖。
@Bean 方法参数注入
- （@Bean ）public UserService userService(Environment env)，会找到Environment类型的bean注入。

代码解释：

@Component
public class Chef {
    private Vegetable vegetable; // 依赖抽象（接口）
    private Egg egg;

    // 管家（Spring）通过构造函数自动注入食材
    public Chef(Vegetable vegetable, Egg egg) { 
        this.vegetable = vegetable;
        this.egg = egg;
    }

    public void cook() {
        Dish dish = new Dish(vegetable, egg);
    }
}


@Component
public class Tomato implements Vegetable { /* ... */ }

@Component
public class Chef {
    @Autowired  // 字段注入
    private Vegetable vegetable;  // Spring 会注入 Vegetable 的实例
    private Egg egg;             // 无 @Autowired，Spring 不会注入（此时 egg = null）

    // 默认无参构造器（Spring 会调用它）
}

public class Chef {
    private Vegetable vegetable;
    private Egg egg;

    // 必需依赖通过构造函数注入
    public Chef(Vegetable vegetable) {
        this.vegetable = vegetable;
    }

    // 可选依赖通过 Setter 注入
    @Autowired(required = false)
    public void setEgg(Egg egg) {
        this.egg = egg;
    }
}

@Bean
public UserService userService(Environment env) {
    // 从环境变量中读取 "env.mode" 的值
    String envMode = env.getProperty("env.mode");
    
    if ("prod".equals(envMode)) {
        return new UserServiceImplA(); // 生产环境实现
    } else {
        return new UserServiceImplB(); // 默认/开发环境实现
    }
}

Spring容器启动阶段都会干什么？

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“beans.xml”);

refresh();

obtainFreshBeanFactory()

finishBeanFactoryInitialization()

▲obtainFreshBeanFactory()

这个方法主要干的是：加载和解析配置文件，保存到对应的 Bean 定义中（保存在BeanDefinition中），然后将这些BeanDefinition注册到beanDefinitionMap中。（用于后续bean实例化做准备。）

BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。

▲finishBeanFactoryInitialization()

这个方法主要干的是：对于单实例bean的创建、属性赋值、初始化。
- preInstantiateSingletons()：处理所有非懒加载的单实例
  - List beanNames = new ArrayList(this.beanDefinitionNames); // 获取所有beanName
  - 处理 FactoryBean
  - 处理普通的 Bean：getBean(beanName);// 初始化所有非懒加载的单实例bean
▲getBean(beanName)

这个方法主要干的是：对于单实例bean的创建、属性赋值、初始化。
- doGetBean()：已经初始化过了就从容器中直接返回，否则就先初始化再返回。
  - createBean() ->Object beanInstance = doCreateBean(beanName, mbdToUse, args) ：获得实例化后的bean实例
▲doCreateBean(beanName, mbdToUse, args)

在这个方法中可以看到bean生命周期的前三个阶段。
- instanceWrapper = this.createBeanInstance(beanName, mbd, args);：实例化阶段
  - return instantiateUsingFactoryMethod(beanName, mbd, args); // 采用工厂方法实例化
  - return autowireConstructor(beanName, mbd, null, null); // 构造函数依赖注入
  - return instantiateBean(beanName, mbd); //使用无参构造器
- this.populateBean(beanName, mbd, instanceWrapper);：属性赋值阶段
- exposedObject = this.initializeBean(beanName, exposedObject, mbd);：初始化阶段

Spring 的 Bean 实例化方式？

方式1：使用构造器实例化

直接通过类的构造器创建 Bean，由 Spring 自动调用。
依赖注入通过构造器参数完成

@Service
public class UserService {
    private final UserRepository userRepository;

    // 构造器注入（Spring 自动注入 UserRepository）
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id);
    }
}

@Repository
public class JpaUserRepository implements UserRepository {
    // 实现数据访问逻辑
}

应用场景：

大多数简单 Bean 的创建，如 Service、Repository 类。

方式2：静态工厂方法

通过类的静态方法返回 Bean 实例，工厂类无需实例化。
方法必须是 static 的。

// 静态工厂类：
public class UserFactory {
    // 静态方法：直接通过类名调用
    public static User createUser() {
        return new User("John");
    }
}

// 注解配置
@Configuration
public class AppConfig {
    @Bean
    public static User user() {
        return UserFactory.createUser(); // 直接调用静态方法，无需实例化 UserFactory
    }
}

“当 @Configuration 类中的 @Bean 方法是静态的且没有其他需要实例化的成员（如非静态方法或 @Autowired 字段）时，Spring 不会创建该配置类的实例。因为静态方法属于类级别，Spring 可以直接通过类名调用，无需实例化对象。但如果配置类中存在非静态方法或依赖注入字段，Spring 会创建实例以满足这些需求。”

应用场景：

创建全局工具类或整合第三方库的 Bean。

@Bean
public static DataSource dataSource() {
    return LegacyDataSourceFactory.createDataSource();
}

@Bean
public static ExecutorService threadPool() {
    return Executors.newFixedThreadPool(10);
}

方式3：实例工厂方法

通过一个已存在的工厂 Bean 的非静态方法创建目标 Bean。
方法是非静态的

@Component
public class DataSourceFactory {
    @Autowired
    private Environment env;  // 注入环境变量（如 application.properties 中的配置）

    public DataSource createDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.password"));
        return dataSource;
    }
}

@Configuration
public class DataSourceConfig {
    @Autowired
    private DataSourceFactory dataSourceFactory;

    @Bean
    public DataSource dataSource() {
        return dataSourceFactory.createDataSource();  // 调用实例方法创建 Bean
    }
    
}

应用场景：工厂类需要依赖其他 Bean 或动态配置

方式4：FactoryBean 接口实例化方式

通过实现 FactoryBean 接口，将复杂对象的创建逻辑封装到 getObject() 方法中。

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory> {
    private DataSource dataSource;

    // 依赖注入数据源
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public SqlSessionFactory getObject() throws Exception {  // SqlSessionFactory创建过程
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mappers/*.xml"));
        return factoryBean.getObject();
    }

    @Override
    public Class<?> getObjectType() {
        return SqlSessionFactory.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

// 配置类中注册 FactoryBean
@Configuration
public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean;
    }
}

应用场景：

适合创建bean实例时需要复杂初始化流程，如整合 MyBatis时，通过 SqlSessionFactoryBean 配置数据源、XML 映射文件路径等，简化 SqlSessionFactory 的创建过程。

bean的生命周期？

实例化、属性赋值、初始化、使用、销毁

实例化：四种实例化方式
属性赋值：
- 1、收集数据：扫描标有@Autowired的字段或方法。
- 2、查找依赖：在bean容器中根据类型或名称查找匹配的bean
- 3、反射注入：通过反射将依赖的bean赋值给字段或者方法。
初始化：
- 1、BeanPostProcessor.postProcessBeforeInitialization()：BeanPostProcessor的前置处理器
- 2、@PostConstruct注解方法：执行bean类中标有这个注解的方法
- 3、InitializingBean.afterPropertiesSet()：让bean实现InitializingBean接口，重写里头的初始化方法
- 4、XML/注解中指定的init-method：@Bean(initMethod = “customInit”)
- 5、BeanPostProcessor.postProcessAfterInitialization()：BeanPostProcessor的后置处理器
使用
销毁

说说循环依赖？

对象A 依赖对象B，对象B 依赖对象A，就成了循环依赖。

A 实例化的时候，发现依赖 B，创建 B 实例，创建 B 的时候发现需要 A，创建 A1 实例……无限套娃。。。。

Spring 怎么解决循环依赖呢？

Spring能解决循环依赖的条件是：单实例bean，且通过 Setter/字段注入（构造器注入无法解决循环依赖）

Spring 通过三级缓存解决单例 Bean 的循环依赖问题。

一级缓存存放已完全初始化的 Bean，
二级缓存存放提前暴露的半成品 Bean（已实例化但未完成属性注入），
三级缓存存放生成半成品 Bean 的 ObjectFactory。

以 A 依赖 B，B 依赖 A 为例：

创建 A 时，实例化后将其 ObjectFactory 放入三级缓存。
填充 A 的属性时发现依赖 B，触发 B 的创建。
创建 B 时同样将 ObjectFactory 放入三级缓存，填充 B 的属性时发现依赖 A，它就从缓存里找 A 对象。依次从⼀级到三级缓存查询 A。
B从三级缓存中通过对象⼯⼚生成A的早期引用，将 A 的早期引用放⼊⼆级缓存，并从三级缓存移除。此时，B 已经实例化并且初始化完成了，把 B 放入⼀级缓存。
A 继续完成属性注入和初始化。顺利从⼀级缓存拿到实例化且初始化完成的 B 对象，A 对象创建也完成，删除⼆级缓存中的 A，同时把 A 放⼊⼀级缓存。
最后，⼀级缓存中保存着实例化、初始化都完成的 A、B 对象。

ObjectFactory。

以 A 依赖 B，B 依赖 A 为例：

创建 A 时，实例化后将其 ObjectFactory 放入三级缓存。
填充 A 的属性时发现依赖 B，触发 B 的创建。
创建 B 时同样将 ObjectFactory 放入三级缓存，填充 B 的属性时发现依赖 A，它就从缓存里找 A 对象。依次从⼀级到三级缓存查询 A。
B从三级缓存中通过对象⼯⼚生成A的早期引用，将 A 的早期引用放⼊⼆级缓存，并从三级缓存移除。此时，B 已经实例化并且初始化完成了，把 B 放入⼀级缓存。
A 继续完成属性注入和初始化。顺利从⼀级缓存拿到实例化且初始化完成的 B 对象，A 对象创建也完成，删除⼆级缓存中的 A，同时把 A 放⼊⼀级缓存。
最后，⼀级缓存中保存着实例化、初始化都完成的 A、B 对象。

【Spring底层分析】Spring IoC

Spring IoC

怎么理解Spring IoC可以降低对象之间的耦合度？

Spring依赖注入的四个方式？

Spring容器启动阶段都会干什么？

Spring 的 Bean 实例化方式？

bean的生命周期？

说说循环依赖？

Spring 怎么解决循环依赖呢？

网站公告

今日签到

热门文章

最新发布