SpringBoot注解大全（详细）
1. @ActiveProfiles
用来声明活动的profile–@ActiveProfiles(“prod”(这个prod定义在配置类中))
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("test")
public class MyApplicationTests {
@Test
public void contextLoads() {
// 你的测试代码
}
}@ActiveProfiles("test") 注解告诉 Spring框架激活名为 test 的配置文件。这意味着 Spring 将会加载与 test 配置文件相关的全部 bean 和配置。假如你有多个配置文件需要激活，可以使用逗号分隔它们，如 @ActiveProfiles("test,test1")。
2. @After
后置建言（advice），标志那些在每个测试方法执行之后都会运行的代码，和@Before相反
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class MyTest {
@Before
public void setUp() {
// 在每个测试方法执行之前运行
}
@Test
public void testMethod1() {
// 测试方法1
}
@Test
public void testMethod2() {
// 测试方法2
}
@After
public void tearDown() {
// 在每个测试方法执行之后运行
}
}这个注解重要用于执行清算工作，比如释放资源、规复测试前的状态等，以确保测试的独立性和可重复性。
3. @Before
前置建言（advice），在原方法前执行。
4. @Around
环绕建言（advice），Spring AOP（面向切面编程）中的一个重要注解，环绕通知是一种在目的方法执行前后插入额外逻辑的增强处理，它可以在方法执行前进行操作，并在方法执行后进行操作，以致可以或许控制目的方法的执行与否、修改返回值或抛出非常。
@Aspect
public class LoggingAspect {
@Around("execution(* com.example.service.*.*(..))")
public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
// 在目标方法执行之前执行的逻辑
System.out.println("Method " + joinPoint.getSignature().getName() + " starts");
// 执行目标方法
Object proceed = joinPoint.proceed();
// 在目标方法执行之后执行的逻辑
long endTime = System.currentTimeMillis();
System.out.println("Method " + joinPoint.getSignature().getName() + " ends. Execution time: " + (endTime - startTime) + " ms");
return proceed;
}
}注意事项
[*]环绕通知中的 proceed() 方法必须被调用，否则目的方法将不会被执行。
[*]环绕通知需要审慎使用，因为不妥的使用可能会导致步伐逻辑出错或性能问题。
[*]确保环绕通知方法的返回类型与目的方法的返回类型一致，以便可以或许精确返回效果。
[*]在环绕通知中处理非常时，要注意非常的传递和处理，避免步伐非常停止。
5. @Aspect
Spring AOP（面向切面编程）中的一个核心注解，用于声明一个类为切面（Aspect）
@Aspect 的重要作用：
[*]声明切面：通过 @Aspect 注解，Spring 容器可以或许识别出哪些类是切面类，进而对它们进行特别的处理。
[*]定义通知：在切面类中，你可以定义各种通知（Advice），如前置通知（Before Advice）、后置通知（After Advice）、环绕通知（Around Advice）等，来指定在目的方法执行的不同阶段需要执行的逻辑。
[*]指定切入点：通过切入点表达式（Pointcut Expression），你可以指定哪些类的哪些方法需要被增强（即哪些方法需要执行通知中定义的逻辑）。
使用 @Aspect 的基本步骤：
[*]引入依赖：确保你的项目中已经引入了 Spring AOP 和 AspectJ 的相关依赖。
[*]定义切面类：使用 @Aspect 注解来声明一个类为切面类。
[*]定义通知：在切面类中，使用 Spring AOP 提供的注解（如 @Before、@After、@Around 等）来定义通知。
[*]指定切入点：在通知注解中，通过 value 或 pointcut 属性来指定切入点表达式，以指定哪些方法需要被增强。
[*]配置切面：将切面类注册到 Spring 容器中，以便 Spring 可以或许识别并处理它。这通常通过 Java 配置或 XML 配置来完成。
@Aspect
@Component // 或者使用 @Configuration 和 @EnableAspectJAutoProxy
public class LoggingAspect {
// 定义一个切入点表达式
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayerExecution() {}
// 使用切入点表达式和 @Before 注解定义前置通知
@Before("serviceLayerExecution()")
public void logBeforeServiceMethod(JoinPoint joinPoint) {
System.out.println("Before executing " + joinPoint.getSignature().getName());
}
// 使用切入点表达式和 @Around 注解定义前置通知
// @Around("serviceLayerExecution()")
// public void logBeforeServiceMethod(JoinPoint joinPoint) {
// System.out.println("Around executing " + joinPoint.getSignature().getName());
// }
// 类似地，你可以定义其他类型的通知，如 @After、@AfterReturning、@AfterThrowing注意事项
[*]确保你的 Spring 容器已经启用了 AOP 支持，这通常通过 @EnableAspectJAutoProxy 注解在配置类上实现。
[*]切入点表达式是 Spring AOP 的强大功能之一，它允许你精确地指定哪些方法需要被增强。
[*]在切面类中定义的通知方法不应有返回值（除了环绕通知），并且它们的参数列表应该与 Spring AOP 要求的参数类型相匹配。
[*]具体使用按照自己代码的业务逻辑
6. @Autowired
Spring 框架中用于实现依赖注入的一个核心注解。它使得 Spring 容器可以或许主动地识别和注入标注了 @Autowired 的字段、构造器参数或方法参数所需的 bean。这极大地简化了依赖管理，使得开发者可以更加专注于业务逻辑的实现，而不是怎样配置和注入依赖
工作原理
当 Spring 容器启动时，它会扫描被 @Component、@Service、@Repository 或 @Controller 等注解标志的类，并将这些类的实例作为 bean 注册到 Spring 容器中。然后，对于每一个标注了 @Autowired 的字段、构造器或方法，Spring 容器会尝试在容器中查找一个类型匹配的 bean，并将其注入到被注解的位置。
使用场景
[*]字段注入：直接在类的字段上使用 @Autowired 注解，Spring 容器会主动将匹配的 bean 注入到这个字段中。
@Autowired
private UserRepository userRepository;
[*]构造器注入：在类的构造器上使用 @Autowired 注解，Spring 容器会在创建类的实例时主动注入构造器参数所需的 bean。
@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
[*]设置方法注入（Setter Injection）：在类的 setter 方法上使用 @Autowired 注解，Spring 容器会在调用这个方法时主动注入所需的 bean。
@Autowired
public void setUserRepository(UserRepository userRepository) {
this.userRepository = userRepository;
}Demo
<img alt="image-20240923112722794" loading="lazy">
长处
[*]减少代码耦合：通过依赖注入，类之间的耦合度低落，更易于维护和测试。
[*]易于配置：使用 @Autowired 可以简化配置过程，减少 XML 配置或 Java 配置的复杂性。
[*]支持主动装配：Spring 容器可以或许主动地识别并注入依赖关系，提高了开发效率。
注意事项
[*]可选依赖：假如某个依赖是可选的，可以在 @Autowired 注解后添加 required = false 属性，如许即使没有匹配的 bean，Spring 也不会抛出非常。
[*]多个候选者：假如 Spring 容器中有多个类型匹配的 bean，并且你需要注入其中一个，那么可能需要使用 @Qualifier 注解来指定具体要注入哪一个 bean。
[*]循环依赖：@Autowired 默认支持构造器注入的循环依赖，但假如是通过字段注入的循环依赖，可能需要额外的配置或避免使用。
7. @Bean
Spring 框架中的一个核心注解，它重要用于在配置类中声明方法，并将这些方法的返回值注册为 Spring 容器中的 Bean
作用
[*]声明 Bean：@Bean 注解用于告诉 Spring 容器，被注解的方法将返回一个对象，该对象要注册为 Spring 应用上下文中的 Bean。
[*]管理 Bean：一旦对象被注册为 Bean，Spring 容器将负责其生命周期的管理，包罗创建、装配和销毁等。
使用
[*]配置类：@Bean 注解通常用在带有 @Configuration 注解的类中，这些类被称为配置类。
[*]方法级别：@Bean 是一个方法级别上的注解，用于标志那些将返回对象作为 Bean 的方法。
@Configuration
public class AppConfig {
@Bean
public UserService userService() {
return new UserService();
}
}特性
[*]依赖注入：@Bean 方法可以依赖其他 Bean，这些依赖将通过方法参数主动注入。
[*]生命周期回调：可以使用 @PostConstruct 和 @PreDestroy 注解来定义 Bean 初始化后和销毁前的回调方法。
[*]指定名称和别名：可以使用 @Bean 注解的 name 或 value 属性来指定 Bean 的名称和别名。
[*]指定作用域：可以使用 @Scope 注解来指定 Bean 的作用域，如 singleton（单例）、prototype（原型）等。
注意事项
[*]方法调用：虽然 @Bean 方法可以被调用，但通常不建议直接调用它们来获取 Bean 实例，而应该通过 Spring 容器来获取。
[*]唯一性：在同一个配置类中，@Bean 方法定义的 Bean 名称默认是方法名，假如有多个方法返回雷同类型的对象但名称不同，则它们会被注册为不同的 Bean。
[*]重载方法：虽然 Java 支持方法重载，但在使用 @Bean 注解时要小心，因为 Spring 容器可能无法精确处理重载的 @Bean 方法，导致不可预测的举动。
[*]@Autowired：用于主动装配 Bean，与 @Bean 配合使用，可以实现依赖的主动注入。
[*]@Component、@Repository、@Service、@Controller：这些注解也是用于定义 Bean 的，但它们通常用于标注具体的类，而 @Bean 是用于标注配置类中的方法。
[*]**@Bean **：是 Spring 框架中定义和管理 Bean 的重要工具，通过它，开发者可以灵活地在配置类中声明和管理 Bean，从而实现依赖注入和对象管理的目的。
8. @Component
Spring 框架中的一个核心注解，它重要用于标识一个类作为 Spring 容器中的组件，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为主动检测的候选对象。同时@Component照旧一个元注解。
作用
[*]组件标识：@Component 注解用于告诉 Spring 容器，被注解的类是一个组件，应该被 Spring 管理。
[*]主动扫描：当使用基于注解的配置时，Spring 容器会扫描带有 @Component 注解的类，并主动实例化它们作为 Spring 应用上下文中的 Bean。
使用
[*]通用组件：当一个类欠好归类到特定的注解（如 @Controller、@Service、@Repository）时，可以使用 @Component 进行标注。
[*]简化配置：@Component 注解简化了 Spring 应用的配置过程，使得开发人员可以或许更加专注于业务逻辑的实现。
衍生注解
[*]@Component 有三个常见的衍生注解：@Controller、@Service 和 @Repository。
[*]@Controller：用于标识控制器类，处理 Web 请求。
[*]@Service：用于标识服务层类，提供业务逻辑。
[*]@Repository：用于标识数据访问对象（DAO），提供数据访问功能。
这些衍生注解不但简化了组件的标识，还带来了额外的利益，如非常转换（@Repository）或 MVC 控制功能（@Controller）
依赖注入
[*]被 @Component 注解的类可以和其他类一样进行主动装配。例如，可以在另一个组件中使用 @Autowired 注解来主动注入一个被 @Component 注解的组件。
[*]@Component 也支持指定组件的名称，使用 @Qualifier 注解可以根据名称来装配组件。
注意事项
[*]虽然 @Component 注解非常灵活，但在实际开发中，建议根据组件的用途选择符合的衍生注解（如 @Controller、@Service、@Repository），以便更好地组织和管理代码。
[*]当使用 @Component 注解时，要确保 Spring 容器可以或许扫描到被注解的类。这通常通过设置 - -@ComponentScan 注解或相应的 XML 配置来实现。
9. @ComponentScan
用于指定 Spring 容器应该扫描哪些包来查找并注册带有特定注解的类（如 @Component、@Service、@Repository、@Controller 等）作为 Spring Bean
作用
根据定义的扫描路径，把符合扫描规则的类装配到 Spring 容器中。如许，Spring 容器就可以或许管理这些类的生命周期，并提供依赖注入等功能。
基本属性
@ComponentScan 注解包罗多个属性，用于自定义组件扫描的举动：
[*]basePackages：指定需要扫描的包名，可以是一个字符串数组，也可以使用点号分隔的包路径。
[*]basePackageClasses：指定包中的某些类，Spring 会扫描这些类所在的包及其子包。
[*]value：与 basePackages 功能雷同，用于指定扫描的包名。
[*]useDefaultFilters：是否使用默认的过滤器。假如设置为 true，则扫描全部带有 @Component、@Service、@Repository 和 @Controller 注解的类。假如设置为 false，则不会使用默认的过滤器，此时可以通过 includeFilters 和 excludeFilters 属性来自定义过滤规则。
[*]includeFilters：指定 Spring 应该包罗哪些类型的类。可以包罗多个过滤器，每个过滤器都包罗一个类型和一个类。
[*]excludeFilters：指定 Spring 不应该包罗哪些类型的类。用法与 includeFilters 类似。
Demo
例如包布局如下：
com
└── example
└── myapp
├── AppConfig.java
└── service
├── UserService.java
└── ProductService.java在 UserService.java 和 ProductService.java 中，我们分别使用 @Service 注解标注了这两个类。然后，在 AppConfig.java 配置类中，我们可以使用 @ComponentScan 注解来指定 Spring 应该扫描的包：
@Configuration
@ComponentScan(basePackages = "com.example.myapp")
public class AppConfig {
// 这里可以定义其他配置 Bean 和设置
}在这个例子中，@ComponentScan 注解被用于 AppConfig 类上，指定 Spring 应该扫描 com.example.myapp 包及其子包，以将组件注册为 Spring Bean。
自定义过滤器
假如需要更细粒度的控制，可以通过 includeFilters 和 excludeFilters 属性来自定义过滤规则。例如，只扫描带有特定注解的类等
@ComponentScan(
basePackages = "com.example.myapp",
useDefaultFilters = false,
includeFilters = {
@Filter(type = FilterType.ANNOTATION, classes = {MyCustomAnnotation.class})
}
)10. @Configuration
它用于指示一个类声明了一个或多个 @Bean 方法，并且这些 @Bean 方法将被 Spring 容器管理，用于生成和管理 Spring 应用上下文中的对象（即 beans）。当你使用 @Configuration 注解一个类时，该类就变成了一个配置类（configuration class），Spring 容器会在启动时处理这个类，并识别出其中的 @Bean 方法。
重要特点
[*]配置类：@Configuration 注解的类被视为一个配置类，它允许你通过 @Bean 注解的方法来定义和初始化 beans。
[*]完全控制：通过配置类，你可以完全控制你的 Spring 应用上下文中的 bean 的创建和配置。
[*]JavaConfig：@Configuration 是 JavaConfig 的一部分，JavaConfig 是挑拨用 Java 类和注解来代替传统的 XML 文件来配置 Spring 应用的方式。
[*]环境抽象：配置类还可以与 @Profile、@PropertySource 等注解结合使用，以支持更复杂的配置需求，如环境特定的配置和属性文件加载。
Demo
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}AppConfig 是一个配置类，它定义了一个名为 myService 的 @Bean 方法。当 Spring 容器启动时，它会调用 myService 方法来创建 MyService 接口的一个实现（MyServiceImpl），并将其注册为 Spring 应用上下文中的一个 bean。如许，你就可以在其他 Spring 管理的组件中通过主动装配（如 @Autowired）来注入这个 MyService bean 了。
注意事项
[*]当你在配置类中使用 @Bean 注解的方法时，Spring 容器会确保每个 bean 只有一个实例（除非你在 @Bean 方法上使用了特定的作用域注解，如 @Scope）。
[*]配置类自己也是由 Spring 容器管理的，但它不是通过 @Bean 方法定义的。相反，它是通过 Spring 容器在启动时扫描到的带有 @Configuration 注解的类来识别的。
[*]配置类中的 @Bean 方法可以互相调用，以构建 bean 之间的依赖关系。但是，要注意避免循环依赖，因为这会导致 Spring 容器在启动时抛出非常。
11. @ConfigurationProperties
它重要用于将配置文件（如 application.properties 或 application.yml）中的属性绑定到 Java 对象上。这个注解极大地简化了配置属性的读取和管理，使得开发者可以或许将外部配置与应用步伐代码解耦，提高代码的可维护性和可扩展性。
重要特点
[*]属性绑定：将配置文件中的属性绑定到 Java 对象的字段上，无需手动编写大量的 getter 和 setter 方法来读取配置。
[*]类型转换：支持将配置文件中的字符串主动转换为 Java 对象的相应类型（如 int、boolean、List、Map 等）。
[*]默认值：当配置文件中没有指定某个属性的值时，可以使用 Java 字段的默认值或通过 @Value 注解指定默认值。
[*]验证：支持对配置属性进行有效性验证，确保配置的精确性。
[*]疏松绑定：支持疏松绑定规则，即属性的名称不需要严格匹配，例如 my-property-name 可以绑定到 myPropertyName 字段上。
Demo
[*]
[*]添加注解：在 Java 类上添加 @ConfigurationProperties 注解，并指定需要绑定的配置文件前缀
@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
private String name;
private int version;
// getter 和 setter 方法
}
[*]
[*]配置文件：在 application.properties 或 application.yml 配置文件中添加相应的属性。
application.properties
myapp.name=My App Name
myapp.version=1.0.0application.yml
myapp:
name: My App Name
version: 1.0.0
[*]
[*]使用配置：通过 Spring 容器获取 MyAppProperties 类的实例，并使用其中的属性值。
@Autowired
private MyAppProperties myAppProperties;
public void doSomething() {
String name = myAppProperties.getName();
int version = myAppProperties.getVersion();
// 使用属性值进行其他操作
}注意事项
[*]前缀：@ConfigurationProperties 注解的 prefix 属性必须小写，否则会报错。
[*]JavaBean 接口：被 @ConfigurationProperties 注解的类需要遵循 JavaBean 规范，即提供公共的 getter 和 setter 方法。
[*]容器组件：只有被 Spring 容器管理的组件（如通过 @Component、@Service 等注解标注的类）才能使用 @ConfigurationProperties 注解的功能。
[*]配置文件处理器：可以导入 Spring Boot 的配置文件处理器依赖，以便在编写配置时获得代码提示。
12. @ContextConfiguration
Spring 测试场景中经常使用，它重要用于加载和配置 Spring 上下文（ApplicationContext）。这个注解允许开发者指定要加载的配置文件或配置类的位置，以便在运行时或测试时可以或许精确地构建和初始化 Spring 上下文。
作用
[*]加载配置文件：用于指定 Spring 配置文件的位置，这些配置文件包罗了 Spring 应用步伐的配置信息，如 bean 的定义、数据源配置等。
[*]加载配置类：也可以用来指定一个或多个包罗 @Configuration 注解的 Java 配置类的位置。
使用
@ContextConfiguration 注解可以通过两种重要方式使用：
[*]
[*]指定配置文件：
使用 locations 属性来指定 XML 配置文件的位置。可以指定一个或多个配置文件，多个文件之间用逗号或数组语法分隔。
示例：@ContextConfiguration(locations = { "classpath:applicationContext.xml", "classpath:test-context.xml" })
[*]
[*]指定配置类：
使用 classes 属性来指定一个或多个配置类的位置。这些类必须包罗 @Configuration 注解。
示例：@ContextConfiguration(classes = { TestConfig.class, AnotherTestConfig.class })
原理
[*]当使用 @ContextConfiguration 注解时，Spring 容器会根据指定的配置文件或配置类来创建和初始化应用步伐上下文。
[*]假如指定了 XML 配置文件，Spring 容器会通过相应的 ContextLoader（如 GenericXmlContextLoader）来加载这些 XML 文件。
[*]假如指定了配置类，Spring 容器则会使用这些配置类中定义的 @Bean 方法来创建和注册 bean。
13. @Controller
用于声明一个类作为 Spring MVC 控制器（Controller）。当一个类被 @Controller 注解标志时，Spring 容器会检测到这个类，并将其注册为一个 Spring MVC 控制器，从而可以或许处理通过 HTTP 请求映射的方法。
作用
[*]定义控制器：@Controller 注解将一个类标志为 Spring MVC 控制器，这意味着这个类中的方法可以处理来自客户端的 HTTP 请求。
[*]请求映射：虽然 @Controller 注解自己不直接处理请求映射，但它常与 @RequestMapping 或其派生注解（如 @GetMapping、@PostMapping 等）一起使用，以将 HTTP 请求映射到控制器中的特定方法上。
[*]视图剖析：控制器方法通常返回一个视图名称或 ModelAndView 对象，Spring MVC 会根据这个返回值找到相应的视图模板，并将其渲染为 HTML 响应返回给客户端。
[*]数据绑定：控制器方法可以接收请求参数、路径变量等，并主动将其绑定到方法参数上，这简化了数据的提取和处理过程。
Demo
[*]添加 @Controller 注解：在类定义前添加 @Controller 注解，将类标志为控制器。
@Controller
public class MyController {
}
[*]定义请求处理方法：在控制器类中定义方法，并使用 @RequestMapping 或其派生注解来映射 HTTP 请求。
@Controller
public class MyController {
@GetMapping("/hello")
public String hello(Model model) {
model.addAttribute("message", "Hello, Spring MVC!");
return "hello"; // 返回视图名称，Spring MVC 会找到相应的视图模板进行渲染
}
}
[*]配置视图剖析器：在 Spring MVC 的配置中，需要配置视图剖析器（ViewResolver），以便 Spring MVC 可以或许根据控制器方法返回的视图名称找到相应的视图模板。
@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
}注意事项
[*]不要与 @RestController 混淆：@RestController 是 @Controller 和 @ResponseBody 的组合注解，它用于创建 RESTful Web 服务。假如你的控制器方法重要返回 JSON 或 XML 等数据而不是视图，则应该使用 @RestController。
[*]路径匹配：在 @RequestMapping 注解中定义的路径是相对于应用步伐的上下文路径的。
[*]方法参数和返回值：控制器方法可以接收各种类型的参数，如 @RequestParam、@PathVariable、Model 等，并可以返回 String（视图名称）、ModelAndView、ResponseEntity、void（配合 HttpServletResponse 使用）等。
[*]非常处理：可以通过 @ExceptionHandler 注解来定义非常处理方法，以处理控制器中抛出的非常。
[*]拦截器：可以通过实现 HandlerInterceptor 接口来创建拦截器，并在 Spring MVC 配置中注册它们，以便在请求处理流程中的不同阶段执行自定义的代码。
14. @ExceptionHandler
Spring MVC 中的一个注解，用于处理控制器中抛出的非常。当你在控制器中处理请求时，可能会碰到各种非常情况，比如数据验证失败、资源找不到、权限不足等。使用 @ExceptionHandler 注解，你可以定义一个或多个方法来专门处理这些非常，从而避免在控制器方法中直接处理非常逻辑，使代码更加清晰和易于维护。
使用
[*]定义非常处理方法：在控制器中，你可以使用 @ExceptionHandler 注解来标志一个或多个方法作为非常处理方法。这些方法需要接收一个非常类型的参数，并可以返回一个视图名称、ModelAndView 对象、ResponseEntity 或其他任何 Spring MVC 支持的响应类型。
[*]指定非常类型：@ExceptionHandler 注解可以指定一个或多个非常类型，表示该方法将处理哪些类型的非常。假如未指定非常类型，则该方法将作为默认非常处理器，处理全部未被其他 @ExceptionHandler 方法捕获的非常。
[*]返回值：非常处理方法的返回值决定了怎样响应客户端。你可以返回一个视图名称来渲染一个错误页面，或者返回一个包罗错误信息的 ResponseEntity 对象。
Demo
@Controller
public class MyController {
// 处理特定类型的异常
@ExceptionHandler(value = MyCustomException.class)
public ResponseEntity<String> handleMyCustomException(MyCustomException ex) {
// 处理异常逻辑
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("自定义异常处理");
}
// 处理所有未捕获的异常（可选）
@ExceptionHandler(Exception.class)
public String handleAllExceptions(Exception ex) {
// 记录日志等操作
return "error"; // 返回错误页面的视图名称
}
// 控制器方法
@GetMapping("/somePath")
public String someMethod() {
// 假设这里抛出了 MyCustomException 异常
throw new MyCustomException("这是一个自定义异常");
}
// 自定义异常类
public static class MyCustomException extends RuntimeException {
public MyCustomException(String message) {
super(message);
}
}
}注意事项
[*]全局非常处理：假如你盼望在整个应用步伐中会合处理非常，而不是在每个控制器中分别处理，你可以创建一个实现了 HandlerExceptionResolver 接口的类，或者更简朴地，使用 @ControllerAdvice 注解来定义一个全局非常处理类。
[*]非常优先级：假如有多个 @ExceptionHandler 方法可以处理同一个非常，Spring MVC 会根据方法的定义次序（从上到下）来选择第一个匹配的方法。因此，你应该注意非常处理方法的定义次序，以确保它们按照你期望的次序被调用。
[*]日志纪录：在非常处理方法中，不要忘记纪录非常信息到日志中，以便在出现问题时进行调试和追踪。
[*]响应客户端：确保你的非常处理方法可以或许向客户端返回清晰、有用的错误信息，以提高用户体验和系统的可维护性。
15. @ModelAttribute
Spring框架中的一个注解，重要用于将HTTP请求中的数据绑定到模型对象，并在视图中进行渲染。它可以应用于方法参数或方法自己，具有灵活的数据处理本领。
使用
[*]方法参数：
当@ModelAttribute注解用于方法参数时，它表示从模型中获取对应的属性值，并将其绑定到方法参数上。这通常用于处理表单提交或URL中的查询参数，主动将请求中的数据填充到对应的JavaBean对象中，并添加到模型中，便于后续方法或视图使用。
@GetMapping("/users/{id}")
public String getUser(@PathVariable("id") int userId, @ModelAttribute("user") User user) {
// 假设这里根据userId从数据库中获取User对象
user = userService.getUserById(userId);
// 方法执行时，user参数已经包含了从数据库获取的User对象
// ...
return "userPage";
}@ModelAttribute("user")注解将请求中或模型中名为"user"的属性绑定到User类型的参数user上。但请注意，这里的实际使用场景可能有所不同，因为通常我们不会将@ModelAttribute用于已经通过@PathVariable等注解获取了数据的参数上。这里的示例重要是为了阐明@ModelAttribute在方法参数上的用法。
[*]方法级别：
当@ModelAttribute注解用于方法自己时，它表示该方法的返回值应该被添加到模型中。这常用于在多个请求处理方法之前，准备共用的模型数据。
@ModelAttribute
public void addAttributes(Model model) {
model.addAttribute("msg", "Hello, Spring MVC!");
}
@GetMapping("/")
public String home() {
// 这里可以直接使用模型中的"msg"属性
// ...
return "homePage";
}addAttributes方法使用了@ModelAttribute注解，其返回值（实际上是void，但通过model.addAttribute方法向模型中添加数据）会在每个请求处理方法之前执行，向模型中添加了一个名为"msg"的属性。如许，在后续的请求处理方法（如home方法）中就可以直接使用这个属性了。
特点
[*]主动绑定：可以主动将请求参数绑定到模型对象，简化了数据绑定的过程。
[*]灵活配置：通过指定属性名称，可以灵活控制模型中的属性名称。
[*]优先级：@ModelAttribute注解的方法会优先于控制器中的其他请求处理方法执行，确保模型数据在请求处理之前就已经准备好。
注意事项
[*]@ModelAttribute注解的方法会在控制器中的每个请求处理方法之前执行（除非有特定的条件阻止其执行），因此在使用时需要审慎，避免不必要的性能开销。
[*]当@ModelAttribute注解用于方法参数时，假如模型中不存在对应的属性，Spring会尝试从请求中查找并绑定数据；假如模型中已存在对应的属性，则直接使用模型中的属性值。
[*]在使用@ModelAttribute注解时，可以通过指定属性名称来控制模型中的属性名称，未指定时则默认使用返回类型的首字母小写作为属性名称（对于方法级别的@ModelAttribute）。
16. @Transactional
Spring 框架中用于声明式事务管理的一个注解。它允许开发者通过简朴的注解来声明某个方法或类需要事务支持，而无需编写复杂的事务管理代码。Spring 会在运行时主动为这些方法或类创建署理对象，并在这些对象的方法执行时应用事务管理。
使用
[*]业务逻辑需要保证数据一致性：当多个数据库操作需要作为一个团体来执行时，使用 @Transactional 可以确保这些操作要么全部成功，要么在碰到错误时全部回滚，从而保持数据的一致性。
[*]简化事务管理：通过声明式事务管理，开发者可以将事务管理的逻辑从业务代码中分离出来，专注于业务逻辑的实现，而无需直接处理事务的开启、提交或回滚等繁琐事务。
[*]提高代码的可读性和可维护性：使用 @Transactional 注解可以使代码更加简便明了，易于明白和维护。
使用
@Transactional 可以应用于接口定义、接口中的方法、类定义或类中的方法上。但是，请注意，由于 Spring 署理机制的限制，该注解在接口定义或接口方法上的效果可能不如预期，因此通常建议将其应用于具体的类方法上。
@Service
public class MyService {
@Transactional
public void myMethod() {
// 执行数据库操作
}
}myMethod 方法被标志为事务性的。当这个方法被调用时，Spring 会主动为这个方法的执行创建一个事务上下文，并在方法执行结束时根据是否出现非常来决定是提交事务照旧回滚事务。
属性
@Transactional 注解还提供了多个属性，允许开发者对事务的举动进行更细致的控制，例如：
[*]propagation：事务的流传举动，定义了当前方法怎样与已存在的事务进行交互。
[*]isolation：事务的隔离级别，定义了事务中的修改对其他事务的可见性。
[*]timeout：事务的超时时间，超过这个时间限制，事务将被主动回滚。
[*]readOnly：标志事务是否为只读事务，只读事务用于不需要修改数据的场景，可以提高性能。
[*]rollbackFor 和 rollbackForClassName：定义了哪些非常会导致事务回滚。
[*]noRollbackFor 和 noRollbackForClassName：定义了哪些非常不会导致事务回滚。
注意事项
[*]方法可见性：@Transactional 注解的方法必须是 public 的，因为 Spring AOP 是通过署理机制来实现的，而署理机制要求被署理的方法必须是 public 的。
[*]自调用问题：在同一个类中，一个 @Transactional 注解的方法调用另一个 @Transactional 注解的方法时，事务的流传举动可能不会按预期工作，因为自调用不会通过署理对象，因此事务管理不会被触发。
[*]非常处理：默认情况下，运行时非常和错误会导致事务回滚，而受检非常则不会。但是，可以通过 @Transactional 注解的 rollbackFor 和 noRollbackFor 属性来自定义哪些非常会导致事务回滚。
17. @Value
Spring 框架中的一个注解，它用于注入配置文件（如 properties 或 YAML 文件）中的值到 Spring 管理的 bean 的字段中。这个注解通常与 @ConfigurationProperties 或直接在 Spring 的组件（如 @Component、@Service、@Controller 等）中使用，以便从外部配置源（如 application.properties 或 application.yml 文件）中读取值。
使用
[*]注入基本类型值：如字符串、整数、布尔值等。
[*]注入复杂类型值：如使用 SpEL（Spring Expression Language）表达式来注入更复杂的值或执行一些操作。
[*]与 @ConfigurationProperties 一起使用：虽然 @ConfigurationProperties 提供了更强大的方式来绑定一组配置到 Java 对象，但 @Value 对于简朴的值注入来说仍然非常有用。
Demo
app.name=MyApp
app.description=This is my application
app.enabled=true
app.number=123import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class MyAppProperties {
@Value("${app.name}")
private String name;
@Value("${app.description}")
private String description;
@Value("${app.enabled}")
private boolean enabled;
@Value("${app.number}")
private int number;
// getters and setters
}注意事项
[*]SpEL 表达式：@Value 注解还支持 SpEL 表达式，允许你执行更复杂的操作，如字符串连接、条件判断等。
[*]默认值：假如配置文件中没有找到对应的属性，你可以为 @Value 注解提供一个默认值，例如 @Value("${some.property:defaultValue}")。
[*]类型安全：虽然 @Value 注解提供了方便的值注入方式，但它可能不如 @ConfigurationProperties 那样类型安全，因为 @ConfigurationProperties 允许你通过 JavaBean 验证来验证配置属性的值。
[*]环境变量和命令行参数：Spring Boot 还允许你通过环境变量和命令行参数来覆盖 application.properties 或 application.yml 文件中的值。这些值同样可以通过 @Value 注解注入到你的应用中。
18. @WebAppConfiguration
Spring框架中的一个类级别的注解，重要用于Spring MVC的集成测试中，以指定测试类所加载的ApplicationContext应该是一个WebApplicationContext。这个注解在测试过程中模仿了ServletContext，并构建了一个WebApplicationContext，从而为测试环境提供了Web应用步伐的环境。
作用
[*]集成测试：重要用于Spring MVC应用步伐的集成测试中，确保测试可以或许运行在Web应用步伐的上下文中。
[*]模仿环境：通过模仿ServletContext，使得测试可以或许更接近实际的Web运行环境。
特性
[*]类级别注解：必须应用于测试类上，而不是测试方法。
[*]主动配置：在Spring Boot应用中，当@WebAppConfiguration被应用到一个@Configuration类上时，Spring Boot会主动配置一个Web环境，包罗启动Servlet容器（如Tomcat）和处理HTTP请求等。
[*]结合使用：通常与@ContextConfiguration注解一起使用，以指定WebApplicationContext的配置位置或配置类。
Demo
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("classpath:spring/applicationContext.xml")
public class MyWebControllerTests {
private MockMvc mockMvc;
@Autowired
private WebApplicationContext webApplicationContext;
@Before
public void setup() {
this.mockMvc = MockMvcBuilders.webAppContextSetup(this.webApplicationContext).build();
}
@Test
public void testMyController() throws Exception {
// 使用mockMvc来模拟HTTP请求并验证响应
}
}注意事项
[*]Spring版本：在Spring 4.0及其之后的版本中，虽然@WebAppConfiguration仍然可用，但Spring提供了更灵活的方式来指定ApplicationContext，因此，在某些情况下，可能不再需要显式地使用@WebAppConfiguration。
[*]资源路径：@WebAppConfiguration允许通过其value()属性来覆盖默认的Web资源路径，从而提供更灵活的配置选项。
[*]继承性：自Spring Framework 5.3起，@WebAppConfiguration注解可以从困绕（enclosing）测试类中主动继承，这简化了注解的使用和管理。
19. @Order
用于定义Spring IOC容器中Bean的执行次序的优先级（这里的次序也可以明白为存放到容器中的先后次序）。它并不直接控制Bean的加载次序，而是影响Bean在特定场景下的执行次序，如依赖注入、事件监听、拦截器/过滤器执行等。
使用
[*]Bean加载次序：
在配置类中，可以使用@Order注解来指定Spring容器中Bean的创建次序。这对于依赖于其他Bean初始化次序的Bean特别有用。需要注意的是，@Order并不严格保证Bean的加载次序，特别是在并发环境下，但它提供了一个执行的优先级指导。
[*]过滤器和拦截器次序：
在Web应用中，@Order注解可用于指定过滤器和拦截器的执行次序。通过设置不同的@Order值，可以确保它们按照指定的次序执行。
[*]事件监听器次序：
在Spring框架中，@Order注解可用于指定事件监听器的执行次序。这有助于确保事件监听器按照特定的次序接收和处理事件。
[*]AOP切面次序：
在使用Spring AOP进行方法拦截时，@Order注解可用于指定切面的执行次序。通过设置不同的@Order值，可以控制切面的执行次序，从而实现对方法的多层次拦截。
[*]JUnit测试执行次序：
在JUnit测试中，@Order注解也可用于定义测试方法的执行次序。这有助于确保测试按照预期的次序运行，尤其是在测试之间存在依赖关系时。
Demo
@Component
@Order(1)
public class FirstBean {
// ...
}@Component
@Order(2)
public class SecondBean {
// ...
}FirstBean将在SecondBean之前被创建（或按优先级执行，具体取决于上下文）。
注意事项
[*]次序值：
@Order注解接收一个整数值作为参数，表示次序。数值越低，优先级越高，意味着该组件或操作会更早地被执行或创建。
[*]默认值：
假如@Order注解没有指定值，它将使用Ordered.LOWEST_PRECEDENCE作为默认值，这通常是Integer.MAX_VALUE，表示最低优先级。
[*]并发环境：
在并发环境下，@Order注解并不能保证严格的执行次序。它更多地是提供一个执行的优先级指导。
[*]与@Priority的关系：
@Priority注解是JSR-250的一部分，它在功能上与@Order类似，但有更广泛的应用，包罗在CDI（Contexts and Dependency Injection）中。
20. @SpringBootTest
是Spring Boot中一个非常重要的测试注解，它简化了集成测试的配置和执行过程，使得开发者可以或许更轻易地创建接近生产环境的测试环境。
作用
[*]创建应用上下文：@SpringBootTest注解的重要用途是在测试过程中方便地创建一个应用上下文（ApplicationContext）。它告诉Spring Boot去探求一个主配置类（比如带有@SpringBootApplication的类），并使用它来启动Spring应用上下文。
[*]集成测试：该注解通常用于测试Spring组件，特别是那些需要与Spring容器交互的组件。它可以或许模仿出一个完备的Spring Boot应用环境，包罗加载全部的Spring配置和Bean，从而使得测试可以或许在一个真实的应用环境中运行。
使用
[*]默认举动：
[*]默认情况下，@SpringBootTest会加载application.properties或application.yml文件中的配置，并启动一个Spring应用上下文。
[*]假如你的应用有多个配置类，可以通过classes属性指定要加载的配置类。
[*]灵活的配置：
[*]excludeAutoConfiguration：使用excludeAutoConfiguration属性来排除特定的主动配置。
[*]properties：使用properties属性来指定测试时使用的属性值，以覆盖默认配置。
[*]webEnvironment：通过webEnvironment属性来指定Web环境，支持的模式包罗MOCK（默认，模仿Servlet环境）、RANDOM_PORT（启动内嵌的Web服务器并监听随机端口）、DEFINED_PORT（启动内嵌的Web服务器并监听指定的端口）等。
[*]与其他注解结合使用：
[*]@SpringBootTest可以与其他Spring注解一起使用，如@DataJpaTest、@RestClientTest等，以提供更具体的测试环境。
[*]假如需要在测试中使用模仿的Bean，可以结合使用@MockBean注解。
[*]当测试Spring MVC控制器时，可以结合使用@SpringBootTest和@WebMvcTest。
[*]主动注入功能：
[*]在使用@SpringBootTest注解的测试类中，可以通过Spring的@Autowired注解主动注入需要的组件和配置，方便进行集成测试。
Demo
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@SpringBootTest
public class MyApplicationTests {
@Autowired
private MyService myService;
@Test
public void testService() {
// 使用myService进行一些测试操作...
assertNotNull(myService, "myService should not be null");
// 其他测试逻辑...
}
}@SpringBootTest注解确保了MyApplication的应用上下文被加载，从而使得MyService可以或许被主动注入到测试类中。如许我们就可以在测试中使用MyService，就像它被Spring管理一样，进行集成测试。
21. @PointCut
AspectJ框架（一个面向切面编程的框架）中的一个核心注解，在Spring AOP（面向切面编程）中也被广泛使用。它用于定义一个切入点（Pointcut），即指定在哪些连接点（Join Point）上应用某个切面（Aspect）的增强逻辑。
定义
[*]定义切入点表达式：@Pointcut注解后面跟着的是一个字符串，这个字符串是一个切入点表达式，用于指定哪些方法会被拦截或增强。
[*]表达式格式：通常使用execution表达式，格式为execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)。其中，各个部分都是可选的，并且可以用通配符（如*）来表示任意值。
组成
[*]修饰符匹配（modifier-pattern?）：方法的修饰符，如public、protected等，可选。
[*]返回值匹配（ret-type-pattern）：方法的返回类型，可以用*表示任意类型，也可以指定具体的类型。
[*]类路径匹配（declaring-type-pattern?）：方法所在的类路径，可以指定具体的类名或包名，包名后可以用..表示该包及其子包下的全部类。
[*]方法名匹配（name-pattern）：具体的方法名，也可以用表示任意方法名，或SomeMethod表示以SomeMethod结尾的方法名。
[*]参数匹配（param-pattern）：方法的参数列表，可以用*表示任意参数，(String)表示一个String类型的参数，(String, int)表示两个参数，第一个是String类型，第二个是int类型。也可以用(..)表示任意数目和类型的参数。
[*]非常类型匹配（throws-pattern?）：方法抛出的非常类型，可选。
用法
[*]匹配全部方法：@Pointcut("execution(* *(..))")
[*]匹配特定包下的全部公有方法：@Pointcut("execution(public * com.example.service..(..))")
[*]匹配特定类及其子包下的全部方法：@Pointcut("execution(* com.example.service..*(..))")
[*]组合表达式：可以使用&&、||、!等逻辑运算符来组合多个切入点表达式。
[*]重用切入点表达式：将切入点表达式定义在一个方法中，然后在其他通知（Advice）中通过方法名来引用这个切入点，从而实现代码的复用。
Demo
@Aspect
@Component
@Slf4j
@Order(1)
public class SqlLoggingAspect {
//定义切点
@Pointcut("execution(* org.example.mapper..*(..))")
public void repositoryExecution() {}
// 在切入点之前执行
@Before("repositoryExecution()")
public void logBefore(JoinPoint joinPoint) {
log.debug("Executing method: " + joinPoint.getSignature().getName());
Object[] args = joinPoint.getArgs();
}
}注意事项
[*]可读性和可维护性：将切入点表达式抽取到一个独立的方法中，可以提高代码的可读性和可维护性。
[*]性能考虑：虽然重用切入点表达式可以提高代码的可读性和可维护性，但过多的抽象和组合可能会低落性能，因为每次执行通知时都需要剖析和匹配切入点表达式。
22. @Service
Spring 框架中的一个注解，它用于标注在服务层（Service Layer）的组件上。Spring 框架的核心思想之一是依赖注入（Dependency Injection, DI），而 @Service 注解正是 Spring 依赖注入功能的一部分。通过使用 @Service 注解，Spring 可以或许主动地检测到被标注的类，并将着实例化、配置并管理起来，同时将这些实例注入到需要它们的类中（比如控制器层（Controller Layer）的类）。
作用
[*]服务层组件标识：@Service 注解的重要用途是告诉 Spring 这是一个服务层组件。服务层通常负责业务逻辑的实现，它位于体现层（如控制器层）和持久层（如数据访问层）之间。
[*]主动装配：Spring 容器可以或许扫描到被 @Service 注解的类，并主动地将其注册为 Spring 应用上下文中的一个 Bean。如许，其他组件（如控制器）就可以通过依赖注入的方式使用这些服务层组件了。
[*]事务管理：虽然 @Service 注解自己并不直接提供事务管理功能，但服务层组件经常需要处理事务。Spring 允许你在服务层方法上使用 @Transactional 注解来声明性地管理事务。
Demo
import org.springframework.stereotype.Service;
@Service
public class UserService {
// 这里可以注入其他依赖，比如数据访问层的组件
public User getUserById(Long id) {
// 实现根据用户ID获取用户的业务逻辑
// ...
return new User();
}
// 其他业务方法...
}UserService 类被 @Service 注解标注，表示它是一个服务层组件。Spring 容器会主动检测到这个类，并将其注册为一个 Bean，然后就可以在需要的地方通过依赖注入的方式使用这个服务了。
注意事项
[*]虽然 @Service 注解是 Spring 提供的，但它实际上是一个泛型的注解，可以用在任何层级的组件上。然而，按照 Spring 的最佳实践，我们通常将 @Service 用于服务层组件，而将 @Repository 用于数据访问层组件，将 @Controller 用于控制器层组件等。
[*]在使用 @Service 注解时，需要确保你的 Spring 配置（无论是基于 XML 的配置照旧基于 Java 的配置）可以或许扫描到被注解的类所在的包。这通常是通过在配置类上添加 @ComponentScan 注解来实现的。
[*]假如你使用的是 Spring Boot，那么通常不需要显式地进行包扫描配置，因为 Spring Boot 会主动扫描启动类所在的包及其子包下的全部组件。
23. @SpingBootApplication
Spring Boot 中的一个核心注解，它重要用于标志 Spring Boot 应用的主配置类。这个注解是一个复合注解，它结合了多个其他 Spring 框架中的注解，以简化 Spring Boot 应用的配置和启动过程。
组成
@SpringBootApplication 注解实际上是以下三个注解的集合：
[*]@SpringBootConfiguration：这是 @Configuration 的一个特别形式，用于定义配置类。它表明该类可以使用 Spring Boot 的主动配置功能，并且可以或许被 Spring 容器管理。
[*]@EnableAutoConfiguration：这个注解启用了 Spring Boot 的主动配置机制。Spring Boot 会根据项目的类路径和依赖关系主动配置各种 Spring 框架和第三方库的功能，减少手动配置的工作量。
[*]@ComponentScan：这个注解用于指定 Spring 容器要扫描的组件的基础包路径。默认情况下，它会扫描当前包及其子包中的组件，如使用 @Component、@Service、@Repository 和 @Controller 等注解的类，并将它们注册为 Spring 应用上下文中的 Bean。
作用
[*]简化配置：通过 @SpringBootApplication 注解，开发者可以快速地启动并运行一个 Spring Boot 应用，而无需进行大量的手动配置。
[*]主动配置：Spring Boot 会根据项目的依赖和类路径中的 Bean 主动配置应用步伐的各个方面，如数据库连接、MVC 配置等，提供开箱即用的功能。
[*]组件扫描：主动扫描并注册带有 @Component、@Service、@Repository 和 @Controller 等注解的类作为 Spring 的 Bean，使得开发者可以方便地使用和管理这些组件。
[*]启动类标识：将带有 @SpringBootApplication 注解的类标识为 Spring Boot 应用步伐的入口点。在运行 Spring Boot 应用步伐时，会起首加载并启动被 @SpringBootApplication 注解标志的类，从而启动整个应用步伐。
Demo
@SpringBootApplication 注解会被添加到主类上
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
// 这里可以定义其他的方法或组件
}@SpringBootApplication 注解简化了启动 Spring Boot 应用的过程。当运行 main 方法时，Spring Boot 会主动进行配置并启动应用。
自定义配置
@SpringBootApplication 注解还允许开发者通过其属性进行自定义配置。例如，使用 exclude 属性可以排除特定的主动配置类，以避免不需要的主动配置。
24. @Profile
重要用于定义特定的配置环境（profile），以便在不同的环境中加载不同的配置或Bean
作用
[*]环境区分：在软件开发过程中，经常需要区分不同的环境，如开发环境（dev）、测试环境（test）、生产环境（prod）等。每个环境可能有不同的配置需求，如数据库连接、日志级别等。@Profile 注解允许开发者为不同的环境定义不同的配置，从而实现环境间的灵活切换。
[*]条件化Bean的创建：通过 @Profile 注解，可以指定某个Bean或配置类只在特定的环境下才会被创建和加载。这有助于减少不必要的资源加载，提高应用的启动速度和运行效率。
[*]提高可维护性和可扩展性：通过为不同的环境定义不同的配置，可以使得应用更加模块化，易于维护和扩展。当需要添加新的环境或修改现有环境的配置时，只需修改对应的配置类或Bean即可，无需修改整个应用的代码。
使用
[*]修饰类：@Profile 可以直接修饰配置类（即带有 @Configuration 注解的类），表示该配置类及其内部的Bean定义只在指定的环境下有效。
@Configuration
@Profile("dev")
public class DevConfig {
// 定义开发环境特有的Bean
}
[*]修饰方法：在配置类中，@Profile 也可以修饰 @Bean 方法，表示该方法定义的Bean只在指定的环境下被创建。
@Configuration
public class DataSourceConfig {
@Bean
@Profile("dev")
public DataSource devDataSource() {
// 返回开发环境的数据源
}
@Bean
@Profile("prod")
public DataSource prodDataSource() {
// 返回生产环境的数据源
}
}
[*]组合使用：@Profile 还支持组合使用多个环境名称，用逗号分隔。这表示该配置或Bean在多个环境下都会生效。
@Bean
@Profile("dev,test")
public DataSource devTestDataSource() {
// 返回开发和测试环境共有的数据源
}注意：使用的时候要激活Profile
在 application.properties 或 application.yml 文件中，通过设置 spring.profiles.active 属性来指定当前激活的Profile。
# application.properties
spring.profiles.active=dev# application.yml
spring:
profiles:
active: dev25. @Reponsitory
专门用于数据访问层（DAO层）的组件
作用
[*]标识数据访问层：@Repository 注解用于标识数据访问层（DAO层）的类，这些类通常负责与数据库进行交互，执行数据的CRUD（创建、读取、更新、删除）操作。
[*]主动检测和管理：通过 @Repository 注解，Spring 容器可以或许主动检测并管理这些 DAO 组件，将它们作为 Bean 注入到应用的其他部分。
[*]非常处理：@Repository 注解还提供了与数据访问相关的非常处理机制，它会主动将数据库相关的非常转换为 Spring 的数据访问非常层次布局（如 DataAccessException），从而简化了非常处理的复杂性。
与其他注解关系
[*]@Component：@Repository 是 @Component 注解的一个特别形式，专门用于数据访问层。虽然它们都可以将类标志为 Spring 容器管理的组件，但 @Repository 提供了更明确的语义和额外的数据访问支持。
[*]@Service 和 @Controller：与 @Repository 类似，@Service 和 @Controller 也是 @Component 注解的扩展，分别用于服务层和控制器层。它们共同构成了 Spring 的分层架构。
使用
[*]关系型数据库访问：@Repository 注解可以应用于操作关系型数据库的 DAO 类，通过 JDBC、JPA 等技术实现数据库操作。
[*]非关系型数据库访问：同样适用于操作非关系型数据库的 DAO 类，如 MongoDB、Redis 等。
[*]消息队列操作：虽然不常见，但理论上 @Repository 注解也可以用于标志操作消息队列的组件，尽管这更多是由 @Service 或其他业务逻辑层组件来处理的。
Demo
@Repository
@Mapper
public interface UserMapper {
List<UserModel> findAll();
UserModel findByName(String username);
String findPswByName(String userName);
void save(UserModel user);
}@Service
public class UserserviceImpl implements UserService {
@Autowired
UserMapper userMapper;
// 登录操作
public String login(UserModel user) {
try {
UserModel userExistN = userMapper.findByName(user.getUsername());
if (userExistN != null) {
String userExistP = userMapper.findPswByName(user.getUsername());
if (userExistP.equals(user.getPassword())) {
return user.getUsername()+"登录成功，欢迎您！";
}else{
return "登录失败，密码错误！";
}
}else {
return "登录失败，用户不存在!";
}
}catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}
}注意事项
[*]非常处理：虽然 @Repository 注解提供了主动的非常转换机制，但在实际应用中，仍然需要根据业务需求进行适当的非常处理。
[*]依赖注入：在使用 @Repository 注解的类中，通常会通过 @Autowired 或其他依赖注入方式注入其他必要的组件或服务。
[*]配置：确保 Spring 配置类或启动类上启用了相应的主动扫描机制（如 @ComponentScan），以便 Spring 可以或许扫描到并管理这些 DAO 组件。
26. @RequestBody
Spring MVC 和 Spring Boot 中常用的一个注解，它用于处理 HTTP 请求的 body 部分。当客户端发送一个请求到服务器时，请求体（body）通常包罗了要发送到服务器的数据。@RequestBody 注解告诉 Spring 的 DispatcherServlet，应该将请求体中的 JSON 或 XML 数据绑定到控制器（Controller）方法的参数上。
使用
[*]POST 和 PUT 请求：在大多数情况下，@RequestBody 用于处理 POST 和 PUT 请求，因为这两种请求类型通常用于提交数据到服务器。
[*]接收 JSON 或 XML 数据：当客户端发送 JSON 或 XML 格式的数据时，@RequestBody 可以帮助将这些数据主动绑定到 Java 对象上。
原理
当控制器方法使用 @RequestBody 注解时，Spring 会使用 HttpMessageConverters 将请求体中的数据转换为 Java 对象。HttpMessageConverters 是一组用于转换 HTTP 请求和响应的类，它们负责将请求体中的数据转换为 Java 对象，以及将 Java 对象转换回响应体数据。
默认情况下，Spring Boot 提供了对 JSON 和 XML 的支持，因此你可以直接接收和发送 JSON 或 XML 数据。但是，你也可以通过添加其他库来支持其他格式的数据。
Demo
// User.java
public class User {
private Long id;
private String name;
// 省略getter和setter方法
}
// UserController.java
@RestController
@RequestMapping("/users")
public class UserController {
@PostMapping("/add")
public ResponseEntity<String> addUser(@RequestBody User user) {
// 这里可以处理user对象，例如保存到数据库
return ResponseEntity.ok("User added successfully!");
}
}当客户端发送一个 POST 请求到 /users/add，并且请求体中包罗了一个 JSON 格式的 User 对象时，Spring 会主动将这个 JSON 数据转换成 User 类的实例，并将其作为 addUser 方法的参数传入。
注意事项
[*]确保你的请求头（Content-Type）精确设置为了 application/json 或其他相应的 MIME 类型，以便 Spring 知道怎样剖析请求体。
[*]假如请求体中的数据无法精确转换成 Java 对象（例如，JSON 格式错误或字段不匹配），Spring 会抛出一个非常。你可以通过全局非常处理来捕获这些非常，并返回友好的错误消息给客户端。
[*]默认情况下，Spring 使用 Jackson 库来剖析 JSON 数据。假如你需要处理 XML 数据，可能需要添加 JAXB 或其他相关依赖。
27. @RequestMapping
Spring MVC 中一个非常核心的注解，它用于将 HTTP 请求映射到特定的处理器（比如控制器中的一个方法）上。这个注解可以声明在类或方法上，用于定义请求的 URL、HTTP 方法（如 GET、POST）、请求参数、请求头等信息，以及它们怎样被映射到特定的处理函数上。
重要属性
[*]value / path：指定请求的 URL 路径。可以是具体的路径，也可以是包罗变量（如 {id}）的路径模板。
[*]method：指定请求的类型（如 GET、POST）。这个属性是 RequestMethod 枚举的一个值或它们的组合。
[*]params：指定请求的必须包罗或不能包罗的参数。
[*]headers：指定请求的必须包罗或不能包罗的 HTTP 头信息。
[*]consumes：指定处理请求的提交内容类型（Content-Type），如 application/json。
[*]produces：指定返回的内容类型，仅当请求头中的（Accept）类型包罗该指定类型才返回。
使用
[*]类级别上的 @RequestMapping
@Controller
@RequestMapping("/users")
public class UserController {
@GetMapping("/{id}")
public String getUserById(@PathVariable("id") Long id, Model model) {
// 根据 id 获取用户信息，并填充到 model 中
return "userDetail"; // 返回视图名
}
@PostMapping
public String createUser(@RequestParam String name, Model model) {
// 创建用户
return "userCreated";
}
}@RequestMapping("/users") 应用于 UserController 类上，这意味着这个类中的全部请求 URL 都会以 /users 开头。然后，@GetMapping("/{id}") 和 @PostMapping 分别用于映射具体的 HTTP GET 和 POST 请求到不同的处理方法上。
2. 方法级别上的 @RequestMapping
@Controller
public class MyController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String sayHello() {
return "hello"; // 返回视图名
}
@RequestMapping(value = "/goodbye", method = RequestMethod.GET, params = "name")
public String sayGoodbye(@RequestParam String name) {
// 仅在请求中包含 'name' 参数时调用
return "goodbye";
}
}@RequestMapping 直接用于方法上，指定了请求的 URL 路径、HTTP 方法以及请求参数。params = "name" 表示这个请求必须包罗名为 name 的参数。
28. @ResponseBody
它用于将控制器的返回值绑定到 web 响应体（Response Body）上。当处理器方法被 @ResponseBody 注解时，Spring 会主动将方法的返回值写入到 HTTP 响应（HttpServletResponse）中。这个过程通常涉及到使用消息转换器（Message Converters）将返回值转换为适当的格式（如 JSON、XML 等），然后写入到响应体中。
作用
[*]RESTful Web 服务：在构建 RESTful Web 服务时，@ResponseBody 非常有用，因为它允许你直接将对象序列化为 JSON 或 XML，并作为 HTTP 响应发送给客户端。
[*]Ajax 请求：在 Ajax 请求中，服务器通常需要返回 JSON 或 XML 格式的数据，@ResponseBody 可以轻松实现这一点。
Demo
有一个用户对象 User 和一个控制器方法，你想要将 User 对象以 JSON 格式返回给客户端。
@RestController // 这是一个方便的注解，相当于在每个方法上都加了 @Controller 和 @ResponseBody
public class UserController {
@GetMapping("/user/{id}")
public User getUserById(@PathVariable Long id) {
// 假设这里有一个服务或DAO层调用，根据id返回User对象
User user = new User();
user.setId(id);
user.setName("John Doe");
// 由于这里使用了 @RestController，或者如果只有这个方法使用了 @ResponseBody，
// Spring 将自动将 User 对象序列化为 JSON 并写入响应体
return user;
}
}
// 如果你没有使用 @RestController，但想要对单个方法应用 @ResponseBody，可以这样做：
@Controller
public class UserController {
@GetMapping("/user/{id}")
@ResponseBody // 告诉 Spring MVC 返回的内容应该绑定到响应体上
public User getUserById(@PathVariable Long id) {
// ... 与上面的示例相同
}
}注意事项
[*]当你使用 @ResponseBody 时，Spring 会查找符合的 HttpMessageConverter 来将你的返回值转换为响应体所需的格式。
[*]假如你正在使用 Spring Boot，并且已经添加了 Spring Web Starter 依赖，那么 Spring Boot 会主动配置一些常用的 HttpMessageConverter，如用于 JSON 的 Jackson 和用于 XML 的 JAXB。
[*]@RestController 是 @Controller 和 @ResponseBody 的组合注解，用于构建 RESTful Web 服务。假如你发现你的控制器中的全部方法都需要 @ResponseBody，那么使用 @RestController 会更简便。
29. @RestController
Spring 4.0 引入的一个注解，它是 @Controller 和 @ResponseBody 的组合注解。当你在一个类上使用 @RestController 注解时，意味着这个类中的全部方法都会默认应用 @ResponseBody 注解的效果，即方法的返回值会主动地绑定到 Web 响应体（Response Body）上，并且通常会被转换为 JSON 或 XML 等格式（这取决于配置的消息转换器）。
作用
[*]RESTful Web 服务：@RestController 是构建 RESTful Web 服务的抱负选择，因为它简化了将对象序列化为 JSON 或 XML 并发送到客户端的过程。
[*]简化配置：假如你发现你的控制器类中的大多数或全部方法都需要 @ResponseBody 注解，那么使用 @RestController 可以减少重复的代码，并使你的控制器类更加简便。
Demo
@RestController
public class UserController {
@GetMapping("/user/{id}")
public User getUserById(@PathVariable Long id) {
// 假设这里有一个服务或DAO层调用，根据id返回User对象
User user = new User();
user.setId(id);
user.setName("John Doe");
// 由于使用了 @RestController，Spring 会自动将 User 对象序列化为 JSON 并写入响应体
return user;
}
@PostMapping("/user")
public ResponseEntity<String> createUser(@RequestBody User user) {
// 假设这里有一个服务层调用，用于创建用户
// 尽管这里返回的是 ResponseEntity，但 @RestController 仍然适用，因为它只关心返回值是否应该被写入响应体
return ResponseEntity.ok("User created successfully");
}
}getUserById 方法返回一个 User 对象，而 createUser 方法返回一个 ResponseEntity 对象。由于 UserController 类被 @RestController 注解，Spring 会主动处理这两个方法的返回值，将它们转换为 JSON（或其他配置的格式）并写入 HTTP 响应体中。
注意事项
[*]当你在一个类上使用 @RestController 时，该类中的全部处理方法都会被视为 @ResponseBody 方法，除非你在方法级别上明确地使用 @ResponseBody(false) 来覆盖这个举动（但通常这不是必要的）。
[*]@RestController 使得构建 RESTful Web 服务变得更加简朴和直接，因为它减少了需要编写的样板代码量。
[*]假如你需要在一个控制器类中混淆使用 @ResponseBody 和非 @ResponseBody 方法（例如，某些方法返回视图名称而不是数据），那么你应该使用 @Controller 而不是 @RestController，并在需要的地方显式地添加 @ResponseBody 注解。
30. @Async
用于声明一个异步方法。当你在方法上使用 @Async 注解时，Spring 会在调用该方法时，在一个单独的线程中异步地执行它。这意味着调用者线程不需要等待被 @Async 注解的方法执行完成，而是可以继续执行其他任务。
作用
[*]提高应用步伐性能：通过异步处理，可以避免在执行长时间运行的任务时阻塞主线程，从而提高应用步伐的响应性和吞吐量。
[*]解耦：异步处理可以帮助你解耦方法的调用和执行，使得方法的调用者不需要关心方法的执行细节和执行时间。
使用
为了使用 @Async 注解，你需要满足以下条件：
[*]配置异步支持：在你的 Spring 配置中启用异步支持。这可以通过在配置类上添加 @EnableAsync 注解来实现。
[*]将 @Async 注解应用于适当的方法：确保 @Async 注解被应用于公共的、非静态的、非void返回类型（或在Java 8+中为CompletableFuture/Future等）的、且没有被 final 修饰的方法上。
[*]返回类型：通常，@Async 方法会返回一个 Future 或 CompletableFuture 对象，以便调用者可以检查异步方法的执行状态或获取效果。但是，也可以返回 void 或其他类型，但如许调用者就无法直接知道异步方法的执行效果或状态。
Demo
@Configuration
@EnableAsync
public class AsyncConfig {
// 这里通常不需要实现任何bean，只需要@EnableAsync注解来启用异步支持
}@Service
public class AsyncService {
@Async
public Future<String> executeAsyncTask(int number) throws InterruptedException {
// 模拟长时间运行的任务
Thread.sleep(1000);
return new AsyncResult<>("AsyncTask completed with value " + number);
}
// 也可以返回void，但这样调用者就无法获取到执行结果
@Async
public void executeVoidAsyncTask(int number) {
// 同样的长时间运行任务
System.out.println("Executing void async task with number " + number);
}
}@RestController
public class AsyncController {
@Autowired
private AsyncService asyncService;
@GetMapping("/async/{number}")
public ResponseEntity<String> asyncEndpoint(@PathVariable int number) throws ExecutionException, InterruptedException {
Future<String> future = asyncService.executeAsyncTask(number);
// 这里可以执行其他任务，而不需要等待异步方法完成
String result = future.get(); // 获取异步方法的执行结果，这将阻塞直到异步方法完成
return ResponseEntity.ok(result);
}
}虽然 Future.get() 方法可以用来获取异步方法的执行效果，但它会阻塞调用线程直到异步方法完成。假如你想要避免阻塞，可以使用 CompletableFuture 并利用它的非阻塞API来处理异步效果。
注意事项
[*]当你在使用 @Async 注解时，确保不要在同一个类中调用异步方法，因为 Spring 的署理机制（通常是基于JDK动态署理或CGLIB）只会对通过Spring容器调用的方法进行署理。假如你在同一个类的方法中调用另一个带有 @Async 注解的方法，那么这个调用将不会被异步处理。
[*]异步方法执行时的非常处理需要特别注意。假如你使用 Future.get() 来获取效果，那么异步方法抛出的任何未捕获的非常都将被封装为 ExecutionException 抛出。假如你使用的是 CompletableFuture，则可以更灵活地处理非常，例如通过 exceptionally 方法来指定非常处理逻辑。
31. @AutoConfigureAfter
它重要用于指示某个主动配置类（Configuration Class）应该在指定的其他主动配置类之后进行主动配置。这个注解提供了一种机制来控制 Spring Boot 主动配置的次序，确保依赖关系的精确性，从而保证应用的精确性和可维护性。
作用
[*]控制主动配置次序：在 Spring Boot 中，有很多主动配置的类，它们会根据系统的环境、条件等主动进行配置。然而，这些配置类有时会依赖于其他的配置类。通过使用 @AutoConfigureAfter 注解，可以确保依赖的配置类先被加载和配置。
[*]保证依赖关系的精确性：当一个主动配置类需要使用另一个主动配置类中的 Bean 或配置时，使用 @AutoConfigureAfter 可以避免由于加载次序错误导致的依赖问题。
使用
[*]注解位置：@AutoConfigureAfter 注解只能用于配置类上，即被 @Configuration 注解修饰的类上。
[*]参数指定：在 @AutoConfigureAfter 注解的 value 属性中，可以指定一个或多个类，这些类必须在指定的主动配置类之后进行主动配置。
Demo
@Configuration
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MyAutoConfiguration {
// ... 配置类的实现 ...
}MyAutoConfiguration 类将在 DataSourceAutoConfiguration 类之后进行主动配置。
注意事项
[*]指定的类必须已存在：@AutoConfigureAfter 注解中指定的类必须已经被 Spring Boot 主动配置或显式定义，否则将抛出 AutoConfigurationOrderFailedException 非常。
[*]多个配置类：假如有多个主动配置类都使用了 @AutoConfigureAfter 注解，那么这些类将按照注解中指定的次序进行加载。
[*]与 @AutoConfigureBefore 的关系：@AutoConfigureBefore 是与 @AutoConfigureAfter 相对应的注解，用于指示某个主动配置类应该在指定的其他主动配置类之前进行主动配置。
32. @Cacheable
重要用于声明性缓存，即将方法的返回值缓存起来，以便在后续雷同方法的调用中可以直接从缓存中获取效果，而无需再次执行方法的实际逻辑。如许做可以明显提高系统的性能和响应速度，特别是在处理读取操作频繁但数据更新不频繁的场景时。
作用
[*]减少数据库访问：对于需要从数据库读取数据的操作，使用 @Cacheable 可以避免重复的数据库查询，减轻数据库压力。
[*]提升性能：通过减少方法的执行次数，低落计算资源的消耗，从而提升系统的团体性能。
使用
在 Spring Boot 项目中，使用 @Cacheable 注解通常需要以下几个步骤：
[*]添加依赖：在项目的 pom.xml 文件中添加 Spring Boot 的缓存启动器依赖，如 spring-boot-starter-cache。
[*]开启缓存：在 Spring Boot 的启动类上添加 @EnableCaching 注解，以开启缓存支持。
[*]配置缓存：根据需要配置缓存的类型（如 Redis、EhCache 等）和相关属性。
[*]使用注解：在需要缓存的方法上添加 @Cacheable 注解，并指定缓存的名称、键的生成计谋等参数。
参数
[*]value/cacheNames：指定缓存的名称，可以是一个字符串或字符串数组，表示方法的效果可以被缓存到哪些缓存中。
[*]key：指定缓存的键，可以是一个 SpEL（Spring Expression Language）表达式，用于根据方法参数动态生成缓存的键。假如不指定，则默认使用方法的参数作为键。
[*]condition：指定缓存的条件，是一个 SpEL 表达式，用于决定在何种情况下将方法的返回值缓存起来。假如不指定，则默认缓存全部效果。
[*]unless：指定缓存的排除条件，也是一个 SpEL 表达式，用于决定在何种情况下不将方法的返回值缓存起来。假如不指定，则默认不排除任何效果。
Demo
@Service
public class MyService {
@Cacheable(value = "myCache", key = "#id")
public String getData(int id) {
// 模拟耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 实际的数据获取逻辑
return "Data for id: " + id;
}
}getData 方法的效果会被缓存到名为 myCache 的缓存中，缓存的键是方法的参数 id。当再次调用 getData 方法并传入雷同的 id 时，假如缓存中存在对应的效果，则直接返回缓存中的值，而不会执行方法的实际逻辑。
注意事项
[*]缓存一致性：在使用 @Cacheable 时，需要关注缓存数据的一致性问题。假如缓存的数据在外部被修改，而系统没有感知到这种变化，就可能导致数据不一致的问题。
[*]缓存穿透：当查询一个不存在的数据时，缓存中不会存储该数据，导致每次查询都会穿透到数据库。可以通过布隆过滤器等机制来避免缓存穿透。
[*]缓存雪崩：当大量缓存同时失效时，全部请求都会直接访问数据库，导致数据库压力骤增。可以通过设置缓存的逾期时间时参加随机因子、使用多级缓存等方式来避免缓存雪崩。
33. @Conditional
用于在基于条件的情况下控制配置类的注册或Bean的创建。这个注解是 Spring 4.0 引入的，作为 Spring 的条件化配置的一部分，它提供了一种灵活的方式来控制哪些配置或Bean应该被包罗在Spring应用上下文中。
使用
@Conditional 注解通常与自定义条件类一起使用，这些条件类实现了 Condition 接口。通过实现 matches(ConditionContext, AnnotatedTypeMetadata) 方法，你可以定义何时应该包罗特定的配置类或Bean。这种方法非常适合于根据运行时环境（如操作系统类型、JVM版本、特定的库是否可用等）来条件化地包罗配置。
工作原理
[*]定义条件：起首，你需要定义一个或多个实现了 Condition 接口的类。在这个类中，你将实现 matches 方法，该方法根据给定的条件返回 true 或 false。
[*]应用条件：然后，你可以将 @Conditional 注解应用于配置类或Bean方法上，并通过其 value 属性指定你的条件类。假如条件类的 matches 方法返回 true，则配置类或Bean将被包罗在Spring应用上下文中；假如返回 false，则将被忽略。
Demo
// 自定义条件类
public class OnWindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// 检查操作系统是否为Windows
return System.getProperty("os.name").toLowerCase().contains("win");
}
}
// 使用@Conditional注解
@Configuration
public class AppConfig {
@Bean
@Conditional(OnWindowsCondition.class)
public MyWindowsSpecificBean myWindowsSpecificBean() {
return new MyWindowsSpecificBean();
}
}
MyWindowsSpecificBean 只有在操作系统为Windows时才会被创建并注册到Spring应用上下文中。注意事项
[*]@Conditional 可以与 @Bean、@Configuration、@Component 等注解一起使用。
[*]Spring提供了多个内置的条件注解，如 @ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnProperty 等，这些注解可以覆盖大多数常见的条件化配置需求。
[*]使用条件化配置时，应注意避免创建复杂的条件逻辑，以保持配置的清晰和可维护性。
34. @ConditionalOnBean
条件注解，用于在容器中存在特定 Bean 的情况下才创建当前 Bean。这个注解通常用在基于 Spring Boot 的应用中，与主动配置（Auto-configuration）功能结合使用，以根据应用的配置和已存在的 Bean 来条件化地注册新的 Bean。
使用
@ConditionalOnBean 注解可以应用于配置类中的 @Bean 方法上。当 Spring 容器中存在指定的 Bean 时，才会执行该方法并创建相应的 Bean。假如不存在指定的 Bean，则该方法会被忽略，不会创建任何 Bean。
属性
有一个 RedisTemplate 的 Bean，并且你只想在 RedisTemplate 存在时才创建 RedisOperBean
@ConditionalOnBean 注解包罗几个属性，用于指定条件细节：
<ul>value：Class[] 类型，指定需要存在的 Bean 的类型。
type：String[] 类型，与 value 属性类似，但允许使用 Bean 的名称（而不是类型）。
annotation：Class
页:
[1]