Spring boot常用注解介绍

20220310004

已于 2023-11-10 10:25:14 修改

阅读量36

点赞数

文章标签： spring boot 后端

于 2023-11-10 10:23:20 首次发布

本文链接：https://blog.csdn.net/2301_77163313/article/details/134324618

版权

一、Spring Boot的介绍以及特点?

1.介绍：

它是由Pivotal团队在2013年开始研发的，14年4月份发布第一个版本的全新开源的轻量级框架。它基于Spring boot 4.0设计，初衷是简化使用Spring 开发应用程序的过程，为了避免繁琐配置工作，开发人员使用Spring boot 只专注于实现应用程序的功能和业务逻辑。

2.特点：

（1）独立运行的 Spring 项目

Spring Boot 可以以 jar 包的形式独立运行，Spring Boot 项目只需通过命令“ java–jar xx.jar” 即可运行。

可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs。

（2）内嵌 Servlet 容器

Spring Boot 使用嵌入式的 Servlet 容器（例如 Tomcat、Jetty 或者 Undertow 等），应用无需打成 WAR 包。

(3)提供 starter 简化 Maven 配置

Spring Boot 提供了一系列的“starter”项目对象模型（POMS）来简化 Maven 配置。

(4)

提供了大量的自动配置

Spring Boot 提供了大量的默认自动配置，来简化项目的开发，开发人员也通过配置文件修改默认配置。

尽可能自动配置Spring容器.

（5）自带应用监控

Spring Boot 可以对正在运行的项目提供监控。

（6）无代码生成和 xml 配置

Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。access point，注：无线接入节点。

二、常用注解：

1.@SpringBootApplication：将类标记为Spring Boot应用程序的入口点。它是一个组合注解，包含了@ComponentScan、@EnableAutoConfiguration和@Configuration注解。实例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

我们创建了一个名为MyApplication的主应用程序类，并在类上添加了@SpringBootApplication注解。这个注解告诉Spring Boot框架，这是一个Spring Boot应用程序的入口类。

在main方法中，我们使用SpringApplication类的run方法来启动应用程序。它会加载配置并启动Spring应用程序上下文，并且自动进行必要的配置，例如扫描注解、初始化Spring Bean等。

除了@SpringBootApplication注解，还有其他一些注解可以用于进一步配置Spring Boot应用程序，例如@EnableAutoConfiguration、@ComponentScan等。这些注解都包含在@SpringBootApplication注解中，因此使用@SpringBootApplication注解已经足够简化了应用程序的配置。

2.@RestController：将类标记为控制器类，用于处理RESTful请求。它结合了@Controller和@ResponseBody注解，用于返回JSON或XML等格式的响应。实例：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

我们创建了一个名为MyController的控制器类，并在类上添加了@RestController注解。这个注解告诉Spring MVC框架，这是一个RESTful风格的控制器类。在控制器类中，我们定义了一个使用@GetMapping注解的hello（）方法。这个方法处理HTTP GET请求，并返回一个字符串“Hello， World！”作为响应。由于@RestController注解的存在，Spring MVC框架会自动将方法的返回值转换为HTTP响应体，并设置正确的Content-Type头。在这个示例中，返回的字符串会被转换为文本响应。

3.@RequestMapping：用于映射HTTP请求的路径和方法。可以用在类级别和方法级别，用于定义控制器的请求路径和处理方法。实例：

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class MyController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String hello() {
        return "Hello, World!";
    }
}

我们创建了一个名为MyController的控制器类，并在类上添加了@RestController和@RequestMapping注解。@RestController注解表示这是一个RESTful风格的控制器类，@RequestMapping注解指定了类级别的URL路径为“/api”，即所有的请求都会在“/api”下进行处理。在控制器类中，我们定义了一个使用@RequestMapping注解的hello（）方法。这个方法处理HTTP GET请求，并返回一个字符串“Hello， World！”作为响应。@RequestMapping注解指定了方法级别的URL路径为“/hello”，并且限定了HTTP方法为GET。由于@RequestMapping注解的存在，Spring MVC框架会根据URL路径和HTTP方法来映射请求到对应的控制器方法。在这个示例中，当发送GET请求到“/api/hello”路径时，会调用hello（）方法并返回“Hello， World！”作为响应。

4.@PathVariable：用于从URL路径中获取参数值，并将其绑定到方法的参数上。常用于处理RESTful风格的URL路径参数。实例：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        return "Hello, " + name + "!";
    }
}

我们创建了一个名为MyController的控制器类，并在类上添加了@RestController注解。在控制器类中，我们定义了一个使用@GetMapping注解的hello（）方法，并在方法参数上添加了@PathVariable注解。这个注解指定了参数name与URL路径中的{name}变量进行绑定。当发送GET请求到“/hello/{name}”路径时，例如“/hello/John”，Spring MVC框架会将“name”变量的值绑定到hello（）方法的name参数上。在这个示例中，方法返回的字符串将会是“Hello， John！”。@PathVariable注解还支持其他的参数配置，例如指定变量的默认值、正则表达式等。你可以根据具体的需求来使用这些配置。

5.@RequestParam：用于从请求中获取参数的值，并将其绑定到方法的参数上。常用于处理请求参数。实例：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/hello")
    public String hello(@RequestParam("name") String name) {
        return "Hello, " + name + "!";
    }
}

创建了一个名为MyController的控制器类，并在类上添加了@RestController注解。在控制器类中，我们定义了一个使用@GetMapping注解的hello（）方法，并在方法参数上添加了@RequestParam注解。这个注解指定了参数name与请求中的查询参数进行绑定。当发送GET请求到“/hello”路径时，并且在查询参数中包含name参数，例如“/hello？name=John”，Spring MVC框架会将“name”参数的值绑定到hello（）方法的name参数上。在这个示例中，方法返回的字符串将会是“Hello， John！”。@RequestParam注解还支持其他的参数配置，例如指定参数的默认值、是否必需等。你可以根据具体的需求来使用这些配置。

6.@RequestBody：用于接收请求体中的数据，并将其绑定到方法的参数上。常用于处理POST请求的JSON数据。实例：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @PostMapping("/hello")
    public String hello(@RequestBody User user) {
        return "Hello, " + user.getName() + "!";
    }
}

创建了一个名为MyController的控制器类，并在类上添加了@RestController注解。在控制器类中，我们定义了一个使用@PostMapping注解的hello（）方法，并在方法参数上添加了@RequestBody注解。这个注解指定了参数user与请求体中的数据进行绑定。在这个示例中，我们假设存在一个名为User的Java类，它包含一个名为name的属性和对应的getter和setter方法。当发送POST请求到“/hello”路径时，并且请求体中包含符合User类结构的JSON数据，例如，Spring MVC框架会将请求体中的数据绑定到hello（）方法的user参数上。在这个示例中，方法返回的字符串将会是“Hello， John！”。{"name": "John"}。注意，@RequestBody注解还支持其他的参数配置，例如指定请求体的媒体类型、是否必需等。你可以根据具体的需求来使用这些配置。

7.@Autowired：用于自动装配依赖对象。通过该注解，Spring Boot会自动在容器中查找匹配的Bean，并将其注入到标注了@Autowired的字段、构造方法或方法参数中。实例：

@Controller
public class MyController {

    @Autowired
    private MyService myService;

    // Setter method
    @Autowired
    public void setMyService(MyService myService) {
        this.myService = myService;
    }

    // Controller methods...

，我们将@Autowired注解应用于myService字段和setMyService（）方法，实现对MyService的自动装配。

8.@ConfigurationProperties：用于将配置文件中的属性值绑定到Java对象上。可以通过该注解实现配置文件的读取和配置属性的注入。使用@ConfigurationProperties实例：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {

    private String name;
    private String version;
    private int timeout;

    // Getters and setters...

}

我们创建了一个名为MyAppProperties的Java类，并在类上添加了@Component和@ConfigurationProperties注解。

@ConfigurationProperties注解的prefix属性指定了配置文件中属性的前缀，这里是“myapp”。这意味着Spring框架会将以“myapp”为前缀的属性值绑定到MyAppProperties类的相应字段上。

在这个示例中，我们定义了name、version和timeout三个字段，并提供了相应的getter和setter方法。

假设在配置文件中存在以下属性：

myapp.name=My Application
myapp.version=1.0.0
myapp.timeout=5000

当Spring应用程序启动时，它会读取配置文件中以“myapp”为前缀的属性，并将它们的值绑定到MyAppProperties类的字段上。

你可以在其他组件中使用@Autowired注解来注入MyAppProperties类的实例，并访问其中的属性值。例如：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private MyAppProperties appProperties;

    @Autowired
    public MyComponent(MyAppProperties appProperties) {
        this.appProperties = appProperties;
    }

    public void doSomething() {
        String name = appProperties.getName();
        String version = appProperties.getVersion();
        int timeout = appProperties.getTimeout();

        // Use the properties...
    }
}

我们创建了一个名为MyComponent的组件类，并在构造函数上使用@Autowired注解将MyAppProperties类的实例注入到appProperties字段中。然后，我们可以通过调用appProperties的getter方法来访问配置文件中的属性值。

9.@Value：用于将配置文件中的属性值直接注入到Java类的字段上。它可以用于字段、构造函数、方法参数等位置。实例：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @Value("${myapp.name}")
    private String appName;

    @Value("${myapp.version}")
    private String appVersion;

    // Getters and setters...

}

创建了一个名为MyComponent的组件类，并在类的字段上使用@Value注解。

@Value注解的参数是一个SpEL表达式，用于指定要注入的属性值的来源。在这个示例中，我们使用了和来指定属性值的来源。${myapp.name}${myapp.version}

假设在配置文件中存在以下属性：

myapp.name=My Application
myapp.version=1.0.0

当Spring应用程序启动时，它会读取配置文件中的属性，并将它们的值注入到MyComponent类的相应字段上。在这个示例中，appName字段将被注入为“My Application”，appVersion字段将被注入为“1.0.0”。

你可以直接访问这些字段来使用注入的属性值。

@Component
public class AnotherComponent {

    @Autowired
    private MyComponent myComponent;

    public void doSomething() {
        String appName = myComponent.getAppName();
        String appVersion = myComponent.getAppVersion();

        // Use the properties...
    }
}

创建了另一个组件类AnotherComponent，并使用@Autowired注解将MyComponent类的实例注入到myComponent字段中。然后，我们可以通过调用myComponent的getter方法来访问注入的属性值。

10.@EnableCaching：用于启用缓存功能。它可以用于配置类上，以启用Spring的缓存支持。实例：

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class AppConfig {

    // Configuration code...

}

我们创建了一个名为AppConfig的配置类，并在类上使用@EnableCaching注解。

@EnableCaching注解告诉Spring启用缓存功能。它会自动创建一个缓存管理器，并将其注册到Spring容器中。

要使用缓存功能，你需要在你的业务类或方法上使用Spring的缓存注解，如@Cacheable、@CachePut、@CacheEvict等。这些注解可以帮助你定义缓存的行为，如缓存的键、缓存的条件等。

下面是一个使用@Cacheable注解的代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable("myCache")
    public String getData(String key) {
        // Code to fetch data from a data source
        return "Data for key: " + key;
    }

}

我们创建了一个名为MyService的服务类，并在getData方法上使用@Cacheable注解。

@Cacheable注解指定了缓存的名称，这里是“myCache”。当调用getData方法时，Spring会首先检查缓存中是否存在以给定key为键的缓存项，如果存在，则直接返回缓存的结果;如果不存在，则执行方法体中的代码，并将结果存入缓存中。

11.@EnableScheduling：用于启用定时任务调度功能。它可以用于配置类上，以启用Spring的定时任务调度支持。实例：

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableScheduling
public class AppConfig {

    // Configuration code...

}

创建了一个名为AppConfig的配置类，并在类上使用@EnableScheduling注解。

@EnableScheduling注解告诉Spring启用定时任务调度功能。它会自动创建一个任务调度器，并将其注册到Spring容器中。

要使用定时任务调度功能，你需要在你的定时任务方法上使用Spring的定时任务注解，如@Scheduled。这些注解可以帮助你定义定时任务的执行时间、频率等。

下面是一个使用@Scheduled注解的代码示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyTask {

    @Scheduled(fixedRate = 5000)
    public void runTask() {
        // Code to be executed periodically
        System.out.println("Executing task...");
    }

}

我们创建了一个名为MyTask的任务类，并在runTask方法上使用@Scheduled注解。

@Scheduled注解指定了定时任务的执行时间和频率。在这个示例中，我们使用了fixedRate属性，表示任务每隔5秒执行一次。

当应用程序启动时，Spring会自动创建一个任务调度器，并根据@Scheduled注解的配置来执行定时任务。

其他一些常用的Spring Boot注解：

@Component：用于标注一个类为Spring组件，让Spring能够自动扫描并将其纳入容器管理。实例:
```
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example")
public class AppConfig {

    // Configuration code...

}
```
在这个示例中，我们创建了一个名为AppConfig的配置类，并在类上使用@Configuration注解。然后，我们使用@ComponentScan注解指定要扫描的包，这里是“com.example”。

@ComponentScan注解告诉Spring在指定的包及其子包中进行组件扫描，并将扫描到的带有@Component注解的类注册为Spring的Bean。补充：@Component注解是一个通用的注解，它可以应用于各种类型的类，包括服务类、存储库类、控制器类等。根据不同的场景，还有一些特定的注解，如@Service、@Repository、@Controller等，它们都是@Component注解的派生注解，用于更具体的用途和语义。
@Service：用于标注一个类为业务逻辑层的组件。实例：
```
import org.springframework.stereotype.Service;

@Service
public class MyService {

    // Service code...

}
```
创建了一个名为MyService的服务类，并在类上使用@Service注解。

@Service注解告诉Spring将这个类识别为一个服务组件，并自动将其实例化为一个Bean，并将其注册到Spring容器中。通过这种方式，我们可以在应用程序的其他地方通过依赖注入的方式使用这个服务。

与@Component注解类似，@Service注解也是@Component注解的派生注解。它提供了更具体的语义，用于表示一个服务类。

为了使@Service注解生效，需要确保在Spring配置中启用了组件扫描。通常，我们会在配置类上使用@Configuration注解，并在其中使用@ComponentScan注解来指定要扫描的包。

下面是一个使用@ComponentScan注解的代码示例：
```
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example")
public class AppConfig {

    // Configuration code...

}
```
在这个示例中，我们创建了一个名为AppConfig的配置类，并在类上使用@Configuration注解。然后，我们使用@ComponentScan注解指定要扫描的包，这里是“com.example”。

@ComponentScan注解告诉Spring在指定的包及其子包中进行组件扫描，并将扫描到的带有@Service注解的类注册为Spring的Bean。
@Repository：用于标注一个类为数据访问层的组件。实例：
```
import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {

    // Repository code...

}
```
我们创建了一个名为MyRepository的存储库类，并在类上使用@Repository注解。

@Repository注解告诉Spring将这个类识别为一个存储库组件，并自动将其实例化为一个Bean，并将其注册到Spring容器中。通过这种方式，我们可以在应用程序的其他地方通过依赖注入的方式使用这个存储库。

与@Component注解类似，@Repository注解也是@Component注解的派生注解。它提供了更具体的语义，用于表示一个存储库类。

为了使@Repository注解生效，需要确保在Spring配置中启用了组件扫描。通常，我们会在配置类上使用@Configuration注解，并在其中使用@ComponentScan注解来指定要扫描的包。

下面是一个使用@ComponentScan注解的代码示例：
```
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example")
public class AppConfig {

    // Configuration code...

}
```
创建了一个名为AppConfig的配置类，并在类上使用@Configuration注解。然后，我们使用@ComponentScan注解指定要扫描的包，这里是“com.example”。

@ComponentScan注解告诉Spring在指定的包及其子包中进行组件扫描，并将扫描到的带有@Repository注解的类注册为Spring的Bean。@Repository注解用于标记一个类为存储库类，表示这个类是用于访问数据库或其他数据存储的组件。它与@Component注解类似，但提供了更具体的语义。在使用@Repository注解时，需要确保在Spring配置中启用了组件扫描。
@Configuration：用于标注一个类为配置类，相当于XML配置文件中的<beans>标签。实例：
```
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    // Configuration code...

}
```
创建了一个名为AppConfig的配置类，并在类上使用@Configuration注解。

@Configuration注解告诉Spring将这个类识别为一个配置类，并在应用程序启动时加载其中的配置信息。配置类通常包含了定义Bean的方法、配置数据源、启用组件扫描等配置项。

在配置类中，我们可以使用其他注解来进一步定义配置信息。例如，我们可以使用@Bean注解来定义一个Bean，并将其注册到Spring容器中。

下面是一个使用@Bean注解的代码示例：
```
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }

}
```
在AppConfig配置类中定义了一个名为myBean的Bean，并使用@Bean注解标记该方法。Spring在启动时会自动调用这个方法，将方法返回的对象注册为一个Bean。

通过@Configuration注解和@Bean注解的配合使用，我们可以在配置类中定义和注册各种Bean，以及进行其他的配置项设置。

为了使@Configuration注解生效，需要在Spring应用程序的入口处进行配置类的加载。通常，我们会使用@EnableAutoConfiguration注解或@Configuration注解来标记主应用程序类，并在其中使用@ComponentScan注解来指定要扫描的包。

下面是一个使用@EnableAutoConfiguration和@ComponentScan注解的代码示例：
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@EnableAutoConfiguration
@ComponentScan("com.example")
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}
```
在这个示例中，我们创建了一个名为Application的主应用程序类，并在类上使用@EnableAutoConfiguration注解和@ComponentScan注解。

@EnableAutoConfiguration注解告诉Spring根据类路径和依赖项自动配置应用程序。@ComponentScan注解指定要扫描的包，这里是“com.example”。总结一下，@Configuration注解用于标记一个类为配置类，表示这个类包含了Spring应用程序的配置信息。通过@Configuration注解和@Bean注解的配合使用，我们可以在配置类中定义和注册各种Bean，以及进行其他的配置项设置。为了使@Configuration注解生效，需要在Spring应用程序的入口处进行配置类的加载。

@Bean：用于在配置类中定义Bean对象。实例：见上一个

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }

}

@Conditional：用于根据条件来决定是否创建一个Bean或配置一个组件。实例：
```
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        return new MyBean();
    }

}
```
在AppConfig配置类中定义了一个名为myBean的Bean，并使用@Conditional注解标记该方法。

@Conditional注解接受一个条件类作为参数，这个条件类实现了Condition接口。在示例中，我们使用了一个名为MyCondition的条件类。

条件类需要实现Condition接口，并重写其中的matches（）方法。matches（）方法用于定义条件的逻辑，如果满足条件，则创建Bean或配置组件，否则忽略。

下面是一个条件类的代码示例：
```
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class MyCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 条件逻辑...
        return true; // 返回true表示满足条件，创建Bean或配置组件
    }

}
```
我们创建了一个名为MyCondition的条件类，并实现了Condition接口。在matches（）方法中，我们可以编写自定义的条件逻辑。

在实际使用中，我们可以根据具体的条件判断来决定是否创建Bean或配置组件。例如，可以根据系统属性、环境变量、配置文件中的值等来判断是否满足条件。

当Spring容器启动时，会自动检查带有@Conditional注解的Bean定义，并根据条件的结果来决定是否创建Bean或配置组件。

总结一下，@Conditional注解用于根据条件来决定是否创建一个Bean或配置一个组件。通过实现Condition接口并重写matches（）方法，可以定义自己的条件逻辑。在应用程序启动时，Spring会自动检查带有@Conditional注解的Bean定义，并根据条件的结果来决定是否创建Bean或配置组件。
@Profile：用于定义不同环境下的配置。实例：
```
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class AppConfig {

    @Bean
    @Profile("dev")
    public MyBean devBean() {
        return new MyBean("Development Bean");
    }

    @Bean
    @Profile("prod")
    public MyBean prodBean() {
        return new MyBean("Production Bean");
    }

}
```
在AppConfig配置类中定义了两个Bean，分别使用了@Profile注解进行标记。

@Profile注解接受一个或多个配置环境名称作为参数。在示例中，我们使用了“dev”和“prod”作为配置环境名称。

当应用程序启动时，Spring会自动根据当前的活动配置环境选择性地加载相应的Bean。

例如，如果将应用程序配置为“dev”环境，那么只有devBean（）方法中定义的Bean会被创建并注册到Spring容器中。而prodBean（）方法中定义的Bean则会被忽略。

可以通过在应用程序的启动配置中设置活动的配置环境来控制加载哪些Bean。可以使用Spring的配置文件、系统属性、环境变量等方式来指定活动的配置环境。

下面是一个使用Spring配置文件指定活动配置环境的示例：
```
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setAdditionalProfiles("dev"); // 设置活动的配置环境为"dev"
        app.run(args);
    }

}
```
在这个示例中，我们使用Spring Boot的@SpringBootApplication注解标记主应用程序类，并在应用程序启动时通过setAdditionalProfiles（）方法设置活动的配置环境为“dev”。

通过@Profile注解，我们可以根据不同的配置环境选择性地加载Bean或配置组件，从而实现在不同的环境中使用不同的配置。

总结，@Profile注解用于根据不同的配置环境选择性地加载Bean或配置组件。可以通过在配置类的方法上使用@Profile注解，并指定配置环境名称来实现条件化的Bean加载。在应用程序启动时，可以通过配置文件、系统属性、环境变量等方式指定活动的配置环境。
@ExceptionHandler：用于定义全局的异常处理方法。实例：
```
@Controller
public class MyController {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception ex) {
        // 异常处理逻辑...
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Internal Server Error");
    }

    @GetMapping("/example")
    public ResponseEntity<String> example() {
        // 抛出异常
        throw new RuntimeException("Something went wrong");
    }

}
```
创建了一个名为MyController的控制器类，并在其中定义了两个方法。

第一个方法是handleException（）方法，使用@ExceptionHandler注解标记，并指定了Exception.class作为参数。这表示该方法用于处理发生的Exception类型的异常。

当控制器中发生Exception类型的异常时，Spring会自动调用handleException（）方法进行异常处理。

handleException（）方法可以接受异常对象作为参数，我们可以在方法体中编写自定义的异常处理逻辑。

在示例中，我们返回了一个包含错误信息的ResponseEntity对象，并设置了状态码为500（HttpStatus.INTERNAL_SERVER_ERROR）。

第二个方法是example（）方法，用于模拟在控制器中抛出异常。

当访问“/example”路径时，example（）方法会抛出一个RuntimeException异常。

由于我们在控制器中定义了handleException（）方法，并且指定了Exception.class作为参数，所以当发生RuntimeException异常时，Spring会自动调用handleException（）方法进行异常处理。

通过使用@ExceptionHandler注解，我们可以集中处理控制器中发生的异常，统一进行异常处理逻辑，避免在每个方法中都进行异常处理。

需要注意的是，@ExceptionHandler注解只能用于控制器类中的方法，并且只能处理控制器中发生的异常。

总结一下，@ExceptionHandler注解用于处理控制器中发生的异常。通过在控制器类的方法上使用@ExceptionHandler注解，并指定异常类型作为参数，可以实现对特定类型异常的统一处理。在处理方法中，可以编写自定义的异常处理逻辑，并返回适当的响应。这样可以集中处理控制器中发生的异常，提高代码的可维护性和可读性。

（还有其他注解望诸位补充)

20220310004

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring boot常用注解介绍

RestController注解表示这是一个RESTful风格的控制器类，@RequestMapping注解指定了类级别的URL路径为“/api”，即所有的请求都会在“/api”下进行处理。在控制器类中，我们定义了一个使用@GetMapping注解的hello（）方法，并在方法参数上添加了@PathVariable注解。根据不同的场景，还有一些特定的注解，如@Service、@Repository、@Controller等，它们都是@Component注解的派生注解，用于更具体的用途和语义。
复制链接

扫一扫