---

前言

@Configuration // 告诉 SpringBoot 这是一个配置类 == 配置文件
@Bean // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例
@Bean(“tom123”) // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例

IOC 容器（Inversion of Control Container）是实现 控制反转 思想的一个运行期框架组件，用来集中创建、装配、管理对象（Bean）及其生命周期。
一句话：原来由程序代码 new 的对象，现在统一交给容器“注入”进来，代码只声明“我需要什么”，而不关心“怎么得到”。

• 控制反转（IoC）：对象创建与依赖绑定的“控制权”从业务代码反转到容器。
• 依赖注入（DI）：容器把依赖对象“注入”到需要它的地方，常见方式：
  • 构造函数注入
  • Setter 注入
  • 字段/注解注入

// 声明组件
@Component
public class OrderService { }@RestController
public class OrderController {@Autowired          // 容器注入private OrderService service;
}

启动 Spring 后，容器扫描注解 → 创建 OrderService → 注入 OrderController，全程无 new。

一、创建两个组件

我们先创建两个组件User和Pet，也就是两个类，放在bean包里面。

package com.hello.bean;/*** 用户*/public class User { // 要把这两个组件添加到容器中private String name;private Integer age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}// 添加带参数的构造方法public User(String name, Integer age){this.name = name;this.age = age;}@Overridepublic String toString() {return "User [name=" + name + ", age=" + age + "]";}}

package com.hello.bean;/*** 宠物*/
public class Pet {private String name;public String getName(){return name;};public void setName(String name){this.name = name;}// 添加构造器public Pet() { // 无参构造器}public Pet(String name) { // 带参构造器this.name = name;}@Overridepublic String toString() {return "Pet{" +"name='" + name + '\'' +'}';}
}

二、使用传统方式

要添加到容器中，首先在资源文件夹中新建beans.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"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user" class="com.hello.bean.User"><property name="name" value="zhangsan"></property><property name="age" value="18"></property></bean><bean id="cat" class="com.hello.bean.Pet"><property name="name" value="tomcat"></property></bean>
</beans>

解释

这个XML文件是一个典型的Spring框架配置文件，用于定义和配置Spring容器中的Bean。下面是对这个配置文件的详细解释：

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

   • 第一行是标准的XML声明
   • 定义了beans根元素和Spring的命名空间
   • 指定了XML Schema定义文件的位置

2. User Bean定义：

   <bean id="user" class="com.hello.bean.User"><property name="name" value="zhangsan"></property><property name="age" value="18"></property>
   </bean>
   

   • 定义了一个ID为"user"的Bean
   • 类路径为com.hello.bean.User
   • 设置了两个属性：
     • name属性值为"zhangsan"
     • age属性值为18

3. Pet Bean定义：

   <bean id="cat" class="com.hello.bean.Pet"><property name="name" value="tomcat"></property>
   </bean>
   

   • 定义了一个ID为"cat"的Bean
   • 类路径为com.hello.bean.Pet
   • 设置了name属性值为"tomcat"

4. 配置特点：

   • 使用了setter注入方式（通过<property>元素）
   • 注入的都是简单值（String和int）
   • 没有定义Bean之间的依赖关系

5. 对应的Java类结构：
   假设的User类：

   package com.hello.bean;public class User {private String name;private int age;// 必须有setter方法public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}
   }
   

   假设的Pet类：

   package com.hello.bean;public class Pet {private String name;public void setName(String name) {this.name = name;}
   }
   

6. 使用场景：

   • 这种配置方式在传统的Spring XML配置中很常见
   • 适用于简单的Bean定义和属性注入
   • 在现代Spring Boot应用中，这种配置方式通常被注解配置（如@Component、@Configuration）取代

注意：要使这个配置正常工作，对应的Java类必须有无参构造函数和相应的setter方法，因为这里使用的是setter注入方式。

三、使用SpringBoot方法

新建config.MyConfig类，在其中写入代码：

源代码

package com.hello.config;import com.hello.bean.User;
import com.hello.bean.Pet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration // 告诉 SpringBoot 这是一个配置类 == 配置文件
public class MyConfig {@Bean // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例public User user01() {return new User("zhangsan", 18);}@Bean // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例public Pet cat(){return new Pet("tomcat");}
}

解释

使用 Java 配置类替代 XML 配置的 Spring Boot 配置示例，下面是对这段代码的详细解释：

1. 类级别注解：

@Configuration // 告诉 SpringBoot 这是一个配置类 == 配置文件
public class MyConfig {

• @Configuration 注解标识这是一个 Spring 配置类，相当于 XML 配置文件
• 配置类中可以定义多个 @Bean 方法，用于向 Spring 容器注册组件

2. User Bean 定义：

@Bean // 给容器中添加组件
public User user01() {return new User("zhangsan", 18);
}

• @Bean 注解表示该方法会返回一个对象，该对象要注册到 Spring 容器中
• 默认情况下，Bean 的名称（ID）就是方法名 user01
• 这里创建了一个 User 对象，使用构造器注入方式设置 name=“zhangsan” 和 age=18

3. Pet Bean 定义：

@Bean // 给容器中添加组件
public Pet cat(){return new Pet("tomcat");
}

• 同样使用 @Bean 注解，Bean 的名称为 cat
• 创建了一个 Pet 对象，设置 name=“tomcat”

4. 与 XML 配置的对比：

   • 等效于之前的 XML 配置，但使用了更现代的 Java 配置方式
   • 不需要 setter 方法，直接使用构造器注入
   • 类型安全，编译器可以检查类型错误
   • 可以方便地添加逻辑（如条件判断等）

5. 对应的 Java 类结构：
   假设的 User 类（需要对应的构造器）：

package com.hello.bean;public class User {private String name;private int age;public User(String name, int age) {this.name = name;this.age = age;}
}

假设的 Pet 类：

package com.hello.bean;public class Pet {private String name;public Pet(String name) {this.name = name;}
}

6. 使用特点：

   • 这是 Spring Boot 推荐的首选配置方式
   • 配置类本身也是一个 Spring 组件（@Configuration 是 @Component 的派生注解）
   • 可以方便地与其他 Spring 特性（如 @Profile, @Conditional 等）结合使用
   • 支持方法间调用（Spring 会拦截确保单例）

7. 获取这些 Bean：
   在应用中可以通过以下方式获取：

// 通过类型获取
User user = applicationContext.getBean(User.class);// 通过名称获取
Pet pet = (Pet) applicationContext.getBean("cat");

这种基于 Java 的配置方式比 XML 更类型安全、更灵活，是现代 Spring Boot 应用的主要配置方式。

四、查看是否添加到组件中

查看

在主程序中进行容器IOC中所有组件的输出。

可以搜到对应的组件，说明组件已经添加成功。

自定义组件名

可以通过@Bean(“tom123”) 这样的方式自定义组件名，这样添加组件名称就是不是默认的方法名。

  @Bean("tom123") // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例public Pet cat(){return new Pet("tomcat");}

我们来进行组件名的输出，点启动项目。在控制台观察、搜索添加的组件。

 public static void main(String[] args) {// 1、返回我们IOC容器ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);// 2、查看容器里面的所有组件String[] names = run.getBeanDefinitionNames();for (String name : names){System.out.println(name);}// 3、从容器中获取组件// 拼接最终启动成功信息String successMessage ="🎉 **启动成功！** (ﾉ◕ヮ◕)ﾉ*:･ﾟ✧\n" +"✨ *服务已就绪，端口 8083* ✨\n" +"💻 访问地址：`http://localhost:8083`\n" +"💪 **Go! Go! Go!** (ง •_•)ง";System.out.println(successMessage);}

这样我们就给容器中注入了两个组件。

配置类在容器中注册的是单实例组件

package com.hello.config;import com.hello.bean.User;
import com.hello.bean.Pet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** 配置类里面使用@Bean标注在方法上给容器中添加组件，默认是单实例的*/
@Configuration // 告诉 SpringBoot 这是一个配置类 == 配置文件
public class MyConfig {@Bean // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例public User user01() {return new User("zhangsan", 18);}@Bean("tom123") // 给容器中添加组件。以方法名作为组件的id,返回类型就是组件类型。返回的值，就是组件在容器中的实例public Pet cat(){return new Pet("tomcat");}
}

我们可以来读取组件对象进行验证一下。

// 3、从容器中获取组件Pet tom1 = run.getBean("tom123", Pet.class);Pet tom2 = run.getBean("tom123", Pet.class);System.out.println("两个组件是否相同" + (tom1 == tom2));

配置类本身也是容器中的一个组件

当时一个类名上加了@Configuratio以后，这个类也会被加入到容器中，作为一个组件。

验证：

MyConfig bean = run.getBean(MyConfig.class);System.out.println(bean);

Configuration的proxyBeanMethods属性：代理bean的方法

应用场景：解决组件依赖问题。

 * 3、proxyBeanMethods：代理bean的方法*  full: 全量模式，IOC容器启动时，会创建所有的单实例Bean（true）*  light: 轻量模式，IOC容器启动时，不会创建单实例Bean，而是当调用getBean方法时，才会创建Bean(false)

proxyBeanMethods 参数详解

proxyBeanMethods 是 @Configuration 注解中的一个重要属性，它决定了配置类中 @Bean 方法是否被代理。下面是它的取值含义表格：

值	含义	适用场景	性能影响	容器行为
true (默认值)	启用代理，确保 @Bean 方法调用总是返回相同的实例（单例）	需要保证单例的场景，方法间有依赖关系时	有轻微性能开销（CGLIB代理）	Spring会拦截方法调用，检查容器中是否已存在该Bean
false	禁用代理，直接调用方法	不需要方法间依赖，或追求启动速度的场景	无代理开销，启动更快	每次调用方法都会真正执行，不保证单例

详细说明

1. proxyBeanMethods = true（默认）

@Configuration(proxyBeanMethods = true)
public class MyConfig {@Beanpublic User user() {return new User(pet()); // 无论调用多少次，返回的都是同一个Pet实例}@Bean public Pet pet() {return new Pet("tomcat");}
}

• 特点：方法间调用会被Spring拦截，确保单例
• 优点：保证Bean的单例性，方法间依赖安全
• 缺点：有CGLIB代理开销

2. proxyBeanMethods = false

@Configuration(proxyBeanMethods = false)
public class MyConfig {@Beanpublic User user() {return new User(pet()); // 每次调用都会new新的Pet实例}@Bean public Pet pet() {return new Pet("tomcat");}
}

• 特点：相当于普通Java方法调用
• 优点：无代理开销，启动更快
• 缺点：不能保证方法间调用的单例性

选择建议

考虑因素	推荐设置
配置类中的@Bean方法需要相互调用	true
需要严格的单例保证	true
追求应用启动速度	false
配置类中没有方法间调用	false
Spring Boot 2.2+ 的@Configuration类	通常设为false

在Spring Boot 2.2+中，很多场景下推荐使用proxyBeanMethods = false以提高性能，特别是大型应用。

总结

本文全面对比了Spring Boot中两种主要的组件配置方式：传统XML配置和现代Java配置类方式，并深入分析了@Configuration和@Bean注解的核心特性。

1. 配置方式演进

   • XML配置是传统Spring的经典方式，通过<bean>标签定义组件，依赖setter注入
   • Java配置类是现代Spring Boot推荐方式，使用@Configuration和@Bean注解，更类型安全灵活

2. 注解核心功能

   • @Configuration标记配置类，替代XML配置文件
   • @Bean注解方法向容器注册组件，默认单例，方法名作为组件ID
   • 支持自定义组件名（@Bean("name")）和方法间依赖调用

3. 高级特性

   • proxyBeanMethods参数控制代理行为，平衡单例保证与性能
   • 配置类本身也是容器组件，可通过上下文获取
   • 与各种条件注解（@Conditional等）无缝集成

4. 实践建议

   • 新项目优先使用Java配置类方式
   • 简单场景可设置proxyBeanMethods=false提升性能
   • 需要严格单例和方法间依赖时保持默认true值
   • 合理命名组件ID提高可读性

现代Spring Boot应用开发中，基于注解的配置方式凭借其类型安全、代码导航方便和与Java语言的天然契合等优势，已成为事实标准。理解这些核心配置机制，是掌握Spring Boot自动配置原理的基础，也是进行高效应用开发的关键。