【Spring底层分析】Spring IoC

发布于:2025-04-16 ⋅ 阅读:(32) ⋅ 点赞:(0)

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 的循环依赖问题。

  1. 一级缓存存放已完全初始化的 Bean,
  2. 二级缓存存放提前暴露的半成品 Bean(已实例化但未完成属性注入),
  3. 三级缓存存放生成半成品 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 对象。

网站公告

今日签到

点亮在社区的每一天
去签到