spring6 IoC容器详解

一、引言

示例开发

示例分析

启用Log4j2日志框架

使用方式

二、IoC容器

IoC容器

1.控制反转（IoC）

2.依赖注入

3.IoC容器在Spring的实现

基于XML管理Bean

依赖注入之setter注入

依赖注入之构造器注入

Bean生命周期

基于xml自动装配

基于注解管理Bean

1.引入依赖

2.开启组件扫描

3.使用注解定义 Bean

4.依赖注入

@Autowired注入

场景一：属性注入

场景二：set注入

场景三：构造方法注入

场景四：形参上注入

场景五：只有一个构造函数，无注解

场景六：@Autowired注解和@Qualifier注解联合

@Resource注入

场景一：根据name注入

场景二：name未知注入

场景三：其他情况

Spring全注解开发

一、引言

示例开发

创建一个maven项目，名称是spring6作为父工程项目，然后在父工程项目里创建一个名称为spring-first的moduel子工程项目。

目录结构如下：

整体开发步骤：

第一步，引入spring相关依赖
第二步，创建类，定义属性和方法
第三步，按照spring要求创建配置文件(xml格式)
第四步，在spring配置文件配置相关信息
第五步，进行最终测试

在子工程项目spring-first的pom.xml文件，引入依赖，

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.example</groupId><artifactId>spring6</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>spring-first</artifactId><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.2</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version></dependency></dependencies>
</project>

然后在子工程项目spring-first的resources目录创建一个 Spring 配置文件 bean.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"><!--配置User所对应的bean，即将User的对象交给Spring的IOC容器管理通过bean标签配置IOC容器所管理的bean属性：id：设置bean的唯一标识class：设置bean所对应类型的全类名--><bean id="user" class="com.example.User"></bean>
</beans>

在子工程项目spring-first的com.example包下创建User类，

package com.example;/*** packageName com.example** @author water* @date 2024/10/16*/
public class User {public User(){System.out.println("0：User的无参构造方法");}public void add(){System.out.println("add...");}
}

在子工程项目spring-first的com.example包下创建测试类，

package com.example;import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** packageName com.example** @author water* @date 2024/10/16*/
public class TestUser {@Testpublic void testObject(){// 加载配置文件ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");// 获取配置创建的对象User user = (User) context.getBean("user");System.out.println("1:" + user);// 使用对象调用方法进行测试System.out.print("2:");user.add();}
}

执行测试方法，结果如下，

示例分析

1. 底层是怎么创建对象的，是通过反射机制调用无参数构造方法吗？

测试得知：创建对象时确实调用了无参数构造方法。

2. Spring是如何创建对象的呢？原理是什么？

// dom4j解析beans.xml文件，从中获取class属性值，类的全类名// 通过反射机制调用无参数构造方法创建对象Class clazz = Class.forName("com.example.User");//Object obj = clazz.newInstance();
User user = (User) clazz.getDeclaredConstructor().newInstance();

3. 把创建好的对象存储到一个什么样的数据结构当中了呢？

bean对象最终存储在spring容器中，在spring源码底层就是一个map集合，存储bean的map在DefaultListableBeanFactory类中：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

Spring容器加载到Bean类时 , 会把这个类的描述信息, 以包名加类名的方式存到beanDefinitionMap 中, Map<String,BeanDefinition>，其中 String是Key，默认是类名首字母小写 BeanDefinition，存的是类的定义(描述信息)，我们通常叫BeanDefinition接口为bean的定义对象。

启用Log4j2日志框架

在项目开发中，日志十分的重要，不管是记录运行情况还是定位线上问题，都离不开对日志的分析。日志记录了系统行为的时间、地点、状态等相关信息，能够帮助我们了解并监控系统状态，在发生错误或者接近某种危险状态时能够及时提醒我们处理，同时在系统产生问题时，能够帮助我们快速的定位、诊断并解决问题。

Apache Log4j2是一个开源的日志记录组件，使用非常的广泛。在工程中以易用方便代替了 System.out 等打印语句，它是JAVA下最流行的日志输入工具。

Log4j2主要由几个重要的组件构成：

（1）日志信息的优先级，日志信息的优先级从高到低有TRACE < DEBUG < INFO < WARN < ERROR < FATAL TRACE：追踪，是最低的日志级别，相当于追踪程序的执行 DEBUG：调试，一般在开发中，都将其设置为最低的日志级别 INFO：信息，输出重要的信息，使用较多 WARN：警告，输出警告的信息 ERROR：错误，输出错误信息 FATAL：严重错误

这些级别分别用来指定这条日志信息的重要程度；级别高的会自动屏蔽级别低的日志，也就是说，设置了WARN的日志，则INFO、DEBUG的日志级别的日志不会显示

（2）日志信息的输出目的地，日志信息的输出目的地指定了日志将打印到控制台还是文件中；

（3）日志信息的输出格式，而输出格式则控制了日志信息的显示内容。

使用方式

整体开发步骤：

引入Log4j2依赖
加入日志配置文件

在子工程项目spring-first的pom.xml文件，引入Log4j2依赖，

 <!--log4j2的依赖--><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.19.0</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.19.0</version></dependency>

然后在子工程项目spring-first的resources目录创建一个log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下）。

<?xml version="1.0" encoding="UTF-8"?>
<configuration><loggers><!--level指定日志级别，从低到高的优先级：TRACE < DEBUG < INFO < WARN < ERROR < FATALtrace：追踪，是最低的日志级别，相当于追踪程序的执行debug：调试，一般在开发中，都将其设置为最低的日志级别info：信息，输出重要的信息，使用较多warn：警告，输出警告的信息error：错误，输出错误信息fatal：严重错误--><root level="DEBUG"><appender-ref ref="spring6log"/><appender-ref ref="RollingFile"/><appender-ref ref="log"/></root></loggers><appenders><!--输出日志信息到控制台--><console name="spring6log" target="SYSTEM_OUT"><!--控制日志输出的格式--><PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/></console><!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用--><File name="log" fileName="d:/my_ruanjian_else/spring6_log/test.log" append="false"><PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/></File><!-- 这个会打印出所有的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档--><RollingFile name="RollingFile" fileName="d:/spring6_log/app.log"filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz"><PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/><SizeBasedTriggeringPolicy size="50MB"/><!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 --><DefaultRolloverStrategy max="20"/></RollingFile></appenders>
</configuration>

其中，存储日志的目录为：

然后，运行原测试程序，会看到多了spring打印日志。

public class TestUser {private Logger logger = LoggerFactory.getLogger(TestUser.class);@Testpublic void testObject() throws Exception {// 加载配置文件ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");// 获取配置创建的对象User user = (User) context.getBean("user");//		// 使用反射创建对象
//		Class clazz = Class.forName("com.example.User");
//		User user = (User) clazz.getDeclaredConstructor().newInstance();System.out.println("1:" + user);// 使用对象调用方法进行测试System.out.print("2:");user.add();logger.info("执行成功");}
}

二、IoC容器

IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。

Spring 通过 IoC 容器来管理所有Java对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。

大致流程：通过xml配置文件告诉IoC容器我要什么对象，IoC容器根据配置信息创建Bean对象，创建用到BeanFactory工厂+单射来创建Bean对象，就是我们所说的实例化。实例化之后，需要进行对象的初始化操作，得到最终可以的对象。就可以通过context.getBean("User);得到这个对象。

IoC 容器是 Spring 框架中最重要的核心组件之一，它贯穿了 Spring 从诞生到成长的整个过程。

IoC容器

1.控制反转（IoC）

控制反转是一种思想。控制反转是为了降低程序耦合度，提高程序扩展力。

控制反转，反转的是什么？将对象的创建权利交出去，交给第三方容器负责。将对象和对象之间关系的维护权交出去，交给第三方容器负责。

控制反转这种思想如何实现呢？DI（Dependency Injection）：依赖注入。

2.依赖注入

依赖注入DI（Dependency Injection），实现了控制反转的思想。换句话说依赖注入是控制反转的一种实现方式。依赖注入指Spring创建对象的过程中，将对象依赖属性通过配置进行注入。依赖注入常见的实现方式包括两种：set注入、构造注入。

所以结论是：IOC 就是一种控制反转的思想，而 DI 是对IoC的一种具体实现。

Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。

3.IoC容器在Spring的实现

Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式：

1）BeanFactory

这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

2）ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

3）ApplicationContext的主要实现类

ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

基于XML管理Bean

一共有下面几种方式：

根据id获取：由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。上个示例中我们使用的就是这种方式。
根据类型获取：要求IOC容器中指定类型的bean有且只能有一个。
根据id和类型获取。

依赖注入之setter注入

创建类，定义属性，生成属性set方法。在spring配置文件配置。

<bean id="studentOne" class="com.example.Student"><!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 --><!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） --><!-- value属性：指定属性值 --><property name="id" value="1001"></property><property name="name" value="张三"></property><property name="age" value="23"></property><property name="sex" value="男"></property></bean>

依赖注入之构造器注入

创建类，定义属性，生成有参数构造方法，然后在spring配置文件进行配置。

<bean id="studentTwo" class="com.atguigu.spring6.bean.Student"><constructor-arg value="1002"></constructor-arg><constructor-arg value="李四"></constructor-arg><constructor-arg value="33"></constructor-arg><constructor-arg value="女"></constructor-arg>
</bean>

使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量。

什么是字面量？

int a = 10;声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。

而如果a是带引号的：'a'，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

Bean生命周期

具体的生命周期过程：

bean对象创建（调用无参数构造）
给bean对象设置相关属性
bean后置处理器（初始化之前）
bean对象初始化（调用指定初始化方法）
bean后置处理器（初始化之后）
bean对象创建完成了，可以使用了
bean对象销毁（需要再配置bean时指定销毁方法）
loC容器关闭

创建bean的后置处理器：

在IOC容器中配置后置处理器：

注意：

其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法。

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行。

基于xml自动装配

自动装配：根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值。

首先，在controller中定义service类型属性，生成service属性set方法，

在serviceImpl中定义dao类型属性，生成dao类型属性set方法，

然后是daoImpl类，

代码执行结果如下，

基于注解管理Bean

从 Java 5 开始，Java 增加了对注解（Annotation）的支持，它是代码中的一种特殊标记，可以在编译、类加载和运行时被读取，执行相应的处理。开发人员可以通过注解在不改变原有代码和逻辑的情况下，在源代码中嵌入补充信息。

Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。

Spring 通过注解实现自动装配的步骤如下：

引入依赖
开启组件扫描
使用注解定义 Bean
依赖注入

1.引入依赖

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.3</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId></dependency><!--log4j2的依赖--><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.19.0</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.19.0</version></dependency>
</dependencies>

2.开启组件扫描

Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。

注意：在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 <beans> 中添加 context 相关的约束。

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--1、开启组件扫描功能--><context:component-scan base-package="com.atguigu.spring6"></context:component-scan>
</beans><!--2、指定要排除的组件--><context:component-scan base-package="com.atguigu.spring6"><!-- context:exclude-filter标签：指定排除规则 --><!-- type：设置排除或包含的依据type="annotation"，根据注解排除，expression中设置要排除的注解的全类名type="assignable"，根据类型排除，expression中设置要排除的类型的全类名--><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--<context:exclude-filter type="assignable" expression="com.atguigu.spring6.controller.UserController"/>-->
</context:component-scan><!--3、仅扫描指定组件-->    <context:component-scan base-package="com.atguigu.spring6"><!-- context:exclude-filter标签：指定排除规则 --><!-- type：设置排除或包含的依据type="annotation"，根据注解排除，expression中设置要排除的注解的全类名type="assignable"，根据类型排除，expression中设置要排除的类型的全类名--><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--<context:exclude-filter type="assignable" expression="com.atguigu.spring6.controller.UserController"/>-->
</context:component-scan>

3.使用注解定义 Bean

Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。

注解	说明
@Component	该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。使用时只需将该注解标注在相应类上即可。
@Repository	该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service	该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller	该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

// @Component
// @Controller
// @Service
@Repository
public class User {}

4.依赖注入

@Autowired注入

@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。

查看源码，可以看到，
package org.springframework.beans.factory.annotation;import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {boolean required() default true;
}
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})表示该注解可以标注在构造方法上、方法上、形参上、属性上、注解上。

该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

场景一：属性注入

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserDao userDao;@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

场景二：set注入

@Service
public class UserServiceImpl implements UserService {private UserDao userDao;@Autowiredpublic void setUserDao(UserDao userDao) {this.userDao = userDao;}@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

场景三：构造方法注入

@Service
public class UserServiceImpl implements UserService {private UserDao userDao;@Autowiredpublic UserServiceImpl(UserDao userDao) {this.userDao = userDao;}@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

场景四：形参上注入

@Service
public class UserServiceImpl implements UserService {private UserDao userDao;public UserServiceImpl(@Autowired UserDao userDao) {this.userDao = userDao;}@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

场景五：只有一个构造函数，无注解

当有参数的构造方法只有一个时，@Autowired注解可以省。

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserDao userDao;public UserServiceImpl(UserDao userDao) {this.userDao = userDao;}@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

场景六：@Autowired注解和@Qualifier注解联合

单独使用@Autowired注解默认根据类型byType注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

@Service
public class UserServiceImpl implements UserService {@Autowired@Qualifier("userDaoImpl") // 指定bean的名字private UserDao userDao;@Overridepublic void out() {userDao.print();System.out.println("Service层执行结束");}
}

@Resource注入

@Resource注解也可以完成属性注入。那它和@Autowired注解有什么区别？

1）@Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型，JSR是Java规范提案)。而@Autowired注解是Spring框架自己的。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。

<dependency><groupId>jakarta.annotation</groupId><artifactId>jakarta.annotation-api</artifactId><version>2.1.1</version>
</dependency>

2）@Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。@Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。

3）@Resource注解用在属性上、setter方法上。而@Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

场景一：根据name注入

@Service
public class UserServiceImpl implements UserService {@Resource(name = "myUserDao")private UserDao myUserDao;@Overridepublic void out() {myUserDao.print();System.out.println("Service层执行结束");}
}

场景二：name未知注入

当@Resource注解使用时没有指定name的时候，还是根据name进行查找，这个name是属性名。

@Service
public class UserServiceImpl implements UserService {@Resourceprivate UserDao myUserDao;@Overridepublic void out() {myUserDao.print();System.out.println("Service层执行结束");}
}

场景三：其他情况

@Service
public class UserServiceImpl implements UserService {@Resourceprivate UserDao userDao1;@Overridepublic void out() {userDao1.print();System.out.println("Service层执行结束");}
}

当通过name找不到的时候，自然会启动byType进行注入，如果UserDao接口下有两个实现类，那么根据类型注入就会报错。

@Resource的set注入可以自行测试。

Spring全注解开发

全注解开发就是不再使用spring配置文件了，写一个配置类来代替配置文件。

package com.example.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration
//@ComponentScan({"com.example.controller", "com.example.service","com.example.dao"})
@ComponentScan("com.example")
public class Spring6Config {
}

@Test
public void testAllAnnotation(){ApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);UserController userController = context.getBean("userController", UserController.class);userController.out();logger.info("执行成功");
}