注解大全(笔记)

　　天真

已于 2023-07-14 09:24:54 修改

阅读量271

点赞数 1

分类专栏： ssm spring spring boot 文章标签：笔记

于 2023-06-29 20:45:53 首次发布

本文链接：https://blog.csdn.net/qq_54794952/article/details/131463075

版权

ssm 同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

spring

1 篇文章 0 订阅

订阅专栏

spring boot

1 篇文章 0 订阅

订阅专栏

1. @Component(组件)

@Component是Spring框架中的一个注解，用于将类标识为一个组件，让Spring容器管理该类的生命周期和依赖注入。

当一个类被标注为@Component时，Spring会自动扫描并将该类实例化，并将其纳入到Spring容器的管理和控制之下。通过使用@Autowired等注解，可以方便地实现对其他组件的依赖注入。

@Component是一个通用的组件注解，可以用于任何类。在实际使用中，一般还有一些特定的子注解，如@Service、@Controller、@Repository等，用于标识特定类型的组件。这些子注解继承了@Component注解，提供了更加具体的语义含义。

以下是一个示例代码，展示如何使用@Component注解：

@Component
public class MyComponent {
    // 该类的成员变量、方法等
}

在上述代码中，MyComponent类被标注为@Component，它变成了一个由Spring容器管理的组件。可以在其他组件中通过@Autowired或其他依赖注入方式来使用该组件。

需要注意的是，使用@Component或其子注解时，需要确保Spring容器对组件的扫描和配置生效。通常需要在Spring配置文件中启用组件扫描，或使用@SpringBootApplication等注解自动启用组件扫描的能力。

2. @Controller(控制器)

@Controller是Spring框架中的一个注解，用于标识一个类为一个控制器（Controller）组件，用于处理用户请求和构建响应。

在Spring MVC框架中，控制器类扮演着处理用户请求、调用业务逻辑和构建响应的角色。通过@Controller注解，可以将一个类标记为控制器，使得Spring容器能自动识别和管理该类，并将其作为请求处理的组件。

使用@Controller注解的类通常会定义一些处理请求的方法，这些方法通过使用@RequestMapping注解来声明对应的请求路径和请求方法。Spring MVC会根据请求的URL匹配映射的方法，并将请求参数等数据传递给方法进行处理，最终返回相应的结果。

以下是一个示例代码，展示了如何使用@Controller注解：

@Controller
public class UserController {
    
    @RequestMapping("/user/{id}")
    public String getUser(@PathVariable("id") int userId, Model model) {
        // 处理用户请求，获取用户信息
        User user = userService.getUserById(userId);
        
        // 将用户信息放入模型
        model.addAttribute("user", user);
        
        // 返回视图名
        return "user";
    }
    
    // 其他处理请求的方法
    // ...
}

在上述代码中，UserController类被标记为@Controller，定义了一个getUser方法来处理请求路径为"/user/{id}“的GET请求。方法通过@PathVariable注解获取请求中的路径参数，调用业务逻辑获取用户信息，并将用户信息添加到Model对象中，最后返回视图名"user”。

需要注意的是，为了让@Controller注解生效，需要在Spring配置中启用组件扫描，并配置正确的视图解析器等其他必要组件。

使用@Controller注解可以让Spring MVC自动管理控制器类，并提供了强大的请求处理能力，使开发Web应用变得更加简单和高效。

3. @Service(业务逻辑)

@Service是Spring框架中的一个注解，用于标识一个类为一个服务（Service）组件，用于封装业务逻辑。

在应用程序中，服务层组件通常用于封装业务逻辑、数据处理和其他复杂的操作。通过将类标记为@Service，Spring容器会自动扫描并管理该类的生命周期，同时也可以使用依赖注入等功能。

与@Component注解类似，@Service是@Component注解的扩展。它们的效果基本相同，但在命名上有不同的语义含义。使用@Service注解可以更清晰地表示一个类是用于封装业务逻辑的服务组件，使代码结构更加清晰和易于理解。

以下是一个示例代码，展示了如何使用@Service注解：

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User getUserById(int userId) {
        // 调用userRepository等方式获取用户信息
        // 进行相关业务逻辑处理
        // ...
        return user;
    }
    
    // 其他业务逻辑方法
    // ...
}

在上述代码中，UserService类被标注为@Service，表示它是一个服务组件。UserService类中定义了一些业务逻辑方法，如getUserById用于根据用户ID获取用户信息。通过使用@Autowired注解，将UserRepository注入到UserService中，以便进行数据访问操作。

请注意，在使用@Service注解时，需要确保Spring容器对组件的扫描和配置生效，通常需要在Spring配置文件中启用组件扫描或使用诸如@SpringBootApplication注解等自动启用组件扫描的能力。

使用@Service注解能够更好地组织和描述应用程序的逻辑结构，并能够和其他Spring组件进行良好的集成和配合使用。同时，它还简化了开发过程中的依赖注入和生命周期管理。

4. @Repository

@Repository是Spring框架中的一个注解，用于标识一个类为一个仓储（Repository）组件，用于访问和操作持久化数据。

在应用程序中，仓储组件通常用于封装对数据库或其他持久化数据源的访问和操作。通过将类标记为@Repository，Spring容器会自动扫描并管理该类的生命周期，并为该类提供依赖注入和异常转译等功能。

与@Component注解类似，@Repository是@Component注解的扩展。它们的效果基本相同，但在命名上有不同的语义含义。使用@Repository注解可以更清晰地表示一个类是用于封装对数据存储的操作的仓储组件。

以下是一个示例代码，展示了如何使用@Repository注解：

@Repository
public class UserRepository {
    
    public User findById(int userId) {
        // 根据用户ID从数据库或其他数据源中查询用户信息
        // ...
        return user;
    }
    
    public void save(User user) {
        // 将用户信息保存到数据库或其他数据源中
        // ...
    }
    
    // 其他数据访问操作方法
    // ...
}

在上述代码中，UserRepository类被标注为@Repository，表示它是一个仓储组件。UserRepository类中定义了一些数据访问操作方法，如findById用于通过用户ID从数据库中查询用户信息，save用于将用户信息保存到数据库中。

请注意，在使用@Repository注解时，需要确保Spring容器对组件的扫描和配置生效，通常需要在Spring配置文件中启用组件扫描或使用诸如@SpringBootApplication注解等自动启用组件扫描的能力。

使用@Repository注解能够更好地组织和描述应用程序的逻辑结构，并能够和其他Spring组件进行良好的集成和配合使用。同时，它还简化了开发过程中对数据访问的处理和管理。

5. @Autowired(自动注入)

当一个类中需要使用另一个类的实例时，可以使用@Autowired注解来实现自动注入。简单来说，就是让Spring框架自动帮我们寻找合适的对象，并将其注入到需要的地方。

假设有一个UserService类，它需要使用一个UserRepository类来访问数据库。我们可以在UserService类中使用@Autowired注解将UserRepository注入进来：

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    // ...
}

通过在userRepository字段上添加@Autowired注解，Spring框架会自动在容器中查找类型为UserRepository的对象，并将其注入到userRepository字段中。

这样做的好处是我们不需要手动创建UserRepository的实例，也不需要在代码中显式地进行赋值操作。Spring会在需要的时候自动为我们完成这些工作，简化了代码，提高了开发效率。

需要注意的是，@Autowired注解可以用在字段上，也可以用在构造函数或setter方法上，具体使用的方式取决于个人偏好和项目需求。

总的来说，@Autowired注解的作用是告诉Spring框架：帮我找到需要的对象，并将其注入到我的类中。这样我们就可以方便地使用其他类的实例，而不用手动管理实例的创建和传递过程。

6. @qualifier

@Qualifier是Spring框架中的一个注解，用于指定依赖项的限定符，以解决自动装配时的歧义性。
防止重名
当存在多个类型相同的实例作为候选项时，Spring容器无法确定要注入哪个实例。这种情况下，可以使用@Qualifier注解配合@Autowired注解来明确指定要注入的bean的名称或限定符。

以下是一个示例，展示了如何使用@Qualifier注解：

@Service
public class UserService {
    
    @Autowired
    @Qualifier("userRepositoryImpl")
    private UserRepository userRepository;
    
    // ...
}

在上述代码中，userRepository字段使用了@Qualifier注解来指定限定符为"userRepositoryImpl"，表示要注入名称为"userRepositoryImpl"的bean。这样就明确了要注入的是哪个具体的实例。

需要注意的是，@Qualifier注解需要与@Autowired注解一起使用，否则限定符信息将不生效。同时，被@Qualifier注解限定的bean也需要在配置中进行相应的命名或配置。

通过使用@Qualifier注解，我们可以明确指定要注入的具体实例，避免了自动装配时的歧义性问题。

总之，@Qualifier注解是Spring框架中用于指定依赖项限定符的注解，用于解决自动装配时的歧义性。通过结合@Qualifier和@Autowired注解的使用，我们可以明确指定要注入的具体实例。

7. @Resource

@Resource是JavaEE标准中的一个注解，用于进行依赖注入（Dependency Injection）。

类似于Spring框架中的@Autowired注解，@Resource注解也可以用于标记需要自动注入的依赖项。它可以用在字段、setter方法或构造函数上。

使用@Resource注解时，可以通过两种方式指定要注入的依赖项：

通过名称匹配：可以使用name属性指定要注入的依赖项的名称。如果依赖项的名称和注入点的名称匹配（使用默认的名称匹配规则），则会将依赖项注入进去。
通过类型匹配：可以直接使用type属性指定要注入的依赖项的类型。当容器中存在符合该类型的依赖项时，会将其注入进去。

以下是一个使用@Resource注解的示例：

@Service
public class UserService {
    
    @Resource(name = "userRepository")
    private UserRepository userRepository;
    
    // ...
}

在上述代码中，userRepository字段使用了@Resource注解，并通过name属性指定要注入的依赖项的名称为"userRepository"。这样，当容器中存在一个名称为"userRepository"的bean时，会将其注入到userRepository字段中。

需要注意的是，@Resource注解是JavaEE标准中的注解，它不依赖于任何特定的框架，而是由JavaEE规范定义。它可以用于标记任何符合JavaEE规范的容器中。

总的来说，@Resource注解是JavaEE规范中的注解，用于进行依赖注入。通过它，可以指定要注入的依赖项的名称或类型，从而实现自动注入的功能。

8. @Value(基本类型装配)

@Value是Spring框架中的一个注解，用于将值注入到类的字段或方法参数中。

@Value注解可以用于注入简单类型的值，如字符串、数字、布尔值等，也可以用于注入复杂类型的值，如数组、集合、对象等。

以下是一些使用@Value注解的示例：

注入简单类型的值：

@Component
public class MyComponent {
    
    @Value("Hello, World!")
    private String greeting;
    
    @Value("42")
    private int answer;
    
    @Value("true")
    private boolean enabled;
    
    // ...
}

在上述代码中，@Value注解直接将值注入到greeting、answer、enabled等字段中。

注入复杂类型的值：

@Component
public class MyComponent {
    
    @Value("${app.server.url}")
    private String serverUrl;
    
    @Value("${app.cache.expiry}")
    private int cacheExpiry;
    
    @Value("#{myBean.value}")
    private int computedValue;
    
    // ...
}

在上述代码中，@Value注解根据特定的表达式或占位符将配置文件中的值注入到serverUrl、cacheExpiry、computedValue等字段中。例如，${app.server.url}表示从配置文件中获取名为app.server.url的属性值，#{myBean.value}表示通过表达式计算得到的值。

需要注意的是，@Value注解可以用于字段、构造函数或setter方法上，具体使用的方式取决于个人偏好和项目需求。

总之，@Value注解是Spring框架中的注解，用于从配置文件或直接注入值到类的字段或方法参数中。通过使用@Value注解，我们可以方便地注入各种类型的值，从而实现更灵活和可配置的组件。

9. @Bean

@Bean是Spring框架中的一个注解，用于告诉Spring容器该方法将返回一个Bean对象，并将其注册到容器中。通常情况下，@Bean注解可以用在@Configuration注解标记的类中的方法上。

使用@Bean注解，我们可以手动创建对象实例，并对其进行配置和初始化。Spring容器会自动处理这些注解，并将Bean对象注册到容器中，以便在其他需要时进行依赖注入。

以下是一个使用@Bean注解的示例：

@Configuration
public class AppConfig {
    
    @Bean
    public UserService userService() {
        // 创建UserService实例，并返回
        return new UserService();
    }
    
    @Bean
    public UserRepository userRepository() {
        // 创建UserRepository实例，并返回
        return new UserRepository();
    }
    
    // ...
}

上述代码中，userService()和userRepository()方法都被@Bean注解标记。这样，Spring容器会在应用启动时自动调用这些方法，并将返回的实例注册为Bean对象。

需要注意的是，@Bean注解可以在方法上使用，也可以在类上使用（作为组件扫描的标记）。方法上的@Bean注解通常用于表示该方法将返回一个Bean对象，而类上的@Bean注解通常用于标记配置类。

当其他类需要使用被@Bean注解标记的Bean对象时，可以通过@Autowired注解或其他方式进行依赖注入。

总之，@Bean注解是Spring框架中的注解，用于告诉Spring容器该方法将返回一个Bean对象，并将其注册到容器中。通过使用@Bean注解，我们可以手动创建和配置Bean对象，以便在应用程序中进行依赖注入和使用。

当我们在使用Spring框架开发应用程序时，我们经常需要创建很多对象并进行配置，同时还希望这些对象能够方便地在不同的地方进行使用。这时候，就可以使用@Bean注解。

简单来说，@Bean注解就像是一个标记，告诉Spring框架某个方法将返回一个被管理的对象（也可以说是一个"Bean"）。我们可以在这个方法中创建对象，并进行一些配置和初始化操作。Spring框架会在启动时自动调用这些被@Bean注解标记的方法，并将返回的对象注册到一个对象池中，以便我们在需要的时候能够方便地获取和使用。

通过使用@Bean注解，我们可以非常灵活地创建和配置对象，而不需要手动管理这些对象的生命周期和依赖关系。而且，这些被@Bean注解标记的对象可以很方便地被其他类进行引用和使用。我们可以使用@Autowired注解或其他方式将这些对象注入到其他类中，实现依赖注入，从而让不同的组件能够协同工作。

总的来说，@Bean注解是Spring框架中的一个特殊注解，用于标记某个方法返回一个被管理的对象，将其加入到Spring框架的对象池中，以便在应用程序的不同地方可以方便地获取和使用。通过使用@Bean注解，我们可以更加轻松地管理和使用对象，提高开发效率和代码的可维护性。

10. @Scope

@Scope是Spring框架中的一个注解，用于指定Bean的作用域（Scope）。在Spring中，Bean的作用域定义了Bean实例的生命周期和可见范围。

Spring框架提供了多种作用域类型供选择，包括：

Singleton（默认）：每个Spring容器中只存在一个Bean实例，所有对该Bean的请求都将返回同一个实例。
Prototype：每次对Bean的请求都会创建一个新的实例。
Request：每次HTTP请求都会创建一个新的实例，适用于Web应用程序。
Session：每个HTTP Session都会创建一个新的实例，适用于Web应用程序。
Global Session：类似于Session作用域，但在Portlet环境中使用。

以下是使用@Scope注解指定Bean作用域的示例：

@Component
@Scope("prototype")
public class MyBean {
    // ...
}

在上述代码中，MyBean类被@Component注解标记，表示它是一个Spring管理的组件。同时，@Scope("prototype")注解指定了该Bean的作用域为Prototype，这意味着每次对MyBean的请求都会创建一个新的实例。

需要注意的是，@Scope注解可以用在类级别或方法级别。当用在类级别时，它指定了整个类中所有Bean实例的作用域。当用在方法级别时，它指定了该方法返回的Bean实例的作用域。

使用@Scope注解，我们可以根据实际需求来选择合适的作用域，控制Bean的生命周期和可见范围，以满足不同场景下的需求。

总之，@Scope注解是Spring框架中的注解，用于指定Bean的作用域。通过使用@Scope注解，我们可以控制Bean实例的生命周期和可见范围，从而满足不同场景下的需求。

Singleton作用域（默认）：
```
@Component
public class MySingletonBean {
    // ...
}
```
在这个例子中，MySingletonBean被标记为@Component注解，默认的作用域是Singleton。这意味着无论在应用程序的哪个地方注入MySingletonBean，都会得到同一个实例，因为Spring容器中只有一个实例存在。
Prototype作用域：
```
@Component
@Scope("prototype")
public class MyPrototypeBean {
    // ...
}
```
在这个例子中，MyPrototypeBean被标记为@Component注解，并使用@Scope("prototype")注解指定了作用域为Prototype。这意味着每次从Spring容器中请求MyPrototypeBean的时候，都会创建一个新的实例。
Request作用域（适用于Web应用程序）：
```
@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyRequestBean {
    // ...
}
```
在这个例子中，MyRequestBean被标记为@Component注解，并使用@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)注解指定了作用域为Request。这意味着每个HTTP请求都会创建一个新的MyRequestBean实例。注意，为了在非单例Bean（如MySingletonBean）内部注入作用域为Request的Bean（如MyRequestBean），可以使用代理模式（ScopedProxyMode.TARGET_CLASS）。

这些只是@Scope注解的一些常见用法。不同的作用域适用于不同的场景，根据具体需求选择适当的作用域可以更好地管理Bean的生命周期和可见范围。

需要注意的是，@Scope注解可以用在类级别或方法级别，可以根据具体的使用场景来决定使用哪种级别。

11. @Import(导入其他类)

@Import是Spring框架中的一个注解，用于导入其他配置类或组件类，以将它们纳入到当前的配置中。通过使用@Import注解，可以实现配置类的模块化、代码重用和组合。

@Import注解可以用在类级别，用于导入其他配置类或组件类。导入的配置类或组件类会在当前配置类中生效，并被Spring容器所管理。

以下是使用@Import注解导入其他配置类的示例：

@Configuration
@Import({DataSourceConfig.class, SecurityConfig.class})
public class AppConfig {
    // ...
}

在上述代码中，AppConfig类被@Configuration注解标记，表示它是一个配置类。同时，通过@Import注解导入了DataSourceConfig和SecurityConfig两个配置类。这样，在AppConfig中，不仅可以定义自己的配置信息，还可以使用和重用这两个导入的配置类中定义的Bean。

除了导入配置类外，@Import注解还可以导入其他类型的组件类，比如普通的类、接口等。导入的组件类也会在当前配置类中进行管理和使用。

需要注意的是，可以在一个配置类中多次使用@Import注解，导入多个配置类或组件类。这样可以将不同的组件模块进行组合，实现更加灵活的配置。

总结来说，@Import注解是Spring框架中的注解，用于导入其他配置类或组件类。通过使用@Import注解，我们可以实现配置类的模块化、代码重用和组合。这种方式能够提高代码的可维护性和可扩展性，使我们能够更好地组织和管理Spring应用程序中的配置信息。

12. @Conditational

@Conditional是Spring框架中的一个注解，用于根据特定条件的结果来决定是否创建某个Bean或配置类。通过使用@Conditional注解，可以根据运行时的环境、配置属性或其他条件动态地控制Bean的创建和加载。

@Conditional注解可以用在类级别或方法级别，用于根据条件进行判断。当条件满足时，被@Conditional注解标记的Bean或配置类才会被创建和加载。

以下是使用@Conditional注解的一个示例：

@Configuration
@Conditional(DatabaseTypeCondition.class)
public class DataSourceConfig {
    // ...
}

在代码中，DataSourceConfig被@Configuration注解标记为配置类，并通过@Conditional(DatabaseTypeCondition.class)注解指定了一个条件类DatabaseTypeCondition。这个条件类实现了Condition接口，根据特定的条件判断逻辑来决定是否应用该配置类。

在运行时，Spring框架会自动检测DatabaseTypeCondition类的条件判断结果。如果条件满足，则DataSourceConfig配置类会被加载和应用；如果条件不满足，则该配置类会被忽略。

Condition接口的实现类可以根据需求自定义，实现不同的条件判断逻辑。Spring框架也提供了一些内置的条件注解，如@ConditionalOnProperty、@ConditionalOnClass、@ConditionalOnBean等，用于根据属性配置、类是否存在、Bean是否存在等条件来进行判断。

通过使用@Conditional注解，可以根据不同的条件动态地控制Bean的创建和加载。这种灵活的条件化配置可以帮助我们根据运行时的环境和需求来决定应用中具体的组件和配置，实现更加灵活和可配置的应用程序。

总结起来，@Conditional注解是Spring框架中的注解，用于根据特定条件来决定是否创建某个Bean或配置类。通过使用@Conditional注解，我们可以根据运行时的条件动态地选择应用不同的配置，提高应用程序的灵活性和可配置性。

13. @ComponentScan

@ComponentScan是Spring框架中的一个注解，用于自动扫描和注册Bean，并将其纳入到Spring容器中进行管理。通过使用@ComponentScan注解，可以方便地进行组件的自动注册和发现，减少显式配置的工作量。

@ComponentScan注解可以用在类级别，用于指定需要被扫描的组件的基础包。Spring框架会自动扫描指定包及其子包下的类，并将被@Component及其派生注解标记的类注册为Bean。

以下是使用@ComponentScan注解进行组件扫描的一个示例：

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

在上述代码中，AppConfig被@Configuration注解标记为配置类，并使用@ComponentScan("com.example")注解指定了需要扫描的基础包为"com.example"。Spring框架会自动扫描该包及其子包下的类，并将被@Component及其派生注解标记的类注册为Bean。

除了可以指定需要扫描的基础包外，@ComponentScan注解还提供了其他属性，用于更精细地控制扫描行为，例如：

basePackages：基础包的数组，用于指定多个基础包进行扫描。
basePackageClasses：基础类的数组，用于指定多个基础类所在的包进行扫描。
includeFilters：过滤器列表，用于包含特定类型的组件。
excludeFilters：过滤器列表，用于排除特定类型的组件。
useDefaultFilters：是否使用默认过滤器，默认为true，表示使用默认过滤器。

通过合理配置这些属性，可以精确控制哪些组件需要被扫描和注册为Bean，以满足不同的需求。

总结来说，@ComponentScan注解是Spring框架中的注解，用于自动扫描和注册Bean。通过使用@ComponentScan注解，我们可以指定需要扫描的基础包，并自动注册被@Component及其派生注解标记的类。这样可以减少手动配置的工作量，提高开发效率。

14. @PropertySource

@PropertySource是Spring框架中的一个注解，用于将外部属性文件加载到Spring的环境中，使得应用程序能够通过@Value注解或Environment对象访问属性值。通过使用@PropertySource注解，可以方便地加载和使用外部属性配置。

@PropertySource注解可以用在类级别，用于指定要加载的属性文件的路径。Spring框架会自动加载指定路径下的属性文件，并将属性值加载到Spring的环境中。

以下是使用@PropertySource注解加载属性文件的一个示例：

@Configuration
@PropertySource("classpath:config.properties")
public class AppConfig {
    // ...
}

在上述代码中，AppConfig被@Configuration注解标记为配置类，并使用@PropertySource("classpath:config.properties")注解指定了要加载的属性文件为"classpath:config.properties"。这意味着Spring会在类路径下找到名为config.properties的文件，并读取其中的属性值。

加载到的属性值可以通过@Value注解直接注入到属性中，例如：

@Component
public class MyComponent {
    @Value("${my.property}")
    private String myProperty;
    
    // ...
}

在上述代码中，MyComponent被@Component注解标记，并使用@Value("${my.property}")注解指定了要注入的属性值的键名。在运行时，Spring会根据配置文件中的属性名my.property，将对应的属性值注入到myProperty字段中。

需要注意的是，@PropertySource注解只会加载属性文件，而不会将属性值注入到Spring的环境中。要使@Value注解或Environment对象能够访问加载的属性值，需要配置PropertySourcesPlaceholderConfigurer bean。可以使用@ComponentScan或手动配置PropertySourcesPlaceholderConfigurer bean。

总结来说，@PropertySource注解是Spring框架中的注解，用于将外部属性文件加载到Spring的环境中，以便应用程序能够访问属性值。通过使用@PropertySource注解，我们可以方便地加载和使用外部属性配置，实现更灵活和可配置的应用程序。

15. @ControllerAdvice

@ControllerAdvice是Spring框架中的一个注解，用于全局处理异常。在控制器类中使用@ControllerAdvice注解可以定义一个全局的异常处理类。

在处理异常方法上使用@ExceptionHandler注解可以定义具体的异常处理方法。

@ControllerAdvice注解可以有多个属性，其中有一个属性是basePackages，用于指定需要扫描的包路径。

16. @ExceptionHandler()

@ExceptionHandler()注解用于指定处理异常的方法。当在方法上使用@ExceptionHandler注解而没有指定具体的异常类型时，该方法会处理所有未被其他ExceptionHandler方法处理的异常。

下面是一个示例：

@ControllerAdvice
public class GlobalExceptionHandler {

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

}

在上面的代码中，handleException方法没有指定具体的异常类型。因此，它会处理所有未被其他ExceptionHandler方法处理的异常。

需要注意的是，如果多个方法都没有指定具体的异常类型，那么只有最后定义的方法会生效。因此，在实际使用中，建议为处理异常的方法指定具体的异常类型，以确保正确的异常处理逻辑被调用。

17. @ResponseBody

@ResponseBody是Spring框架中的注解，用于指示方法的返回值应该直接作为响应体返回，而不是被视图解析器解析为视图。通常用于返回JSON数据或其他格式的响应。

使用@ResponseBody注解可以将方法返回的对象直接序列化为JSON字符串或其他格式，并作为HTTP响应的内容返回给客户端。

下面是一个使用@ResponseBody注解的示例：

@Controller
public class MyController {

    @GetMapping("/data")
    @ResponseBody
    public Map<String, String> getData() {
        Map<String, String> data = new HashMap<>();
        data.put("key1", "value1");
        data.put("key2", "value2");
        return data;
    }

}

在上面的代码中，getData方法使用@ResponseBody注解，它返回一个Map对象。当请求/data时，该方法会将Map对象序列化为JSON字符串，并将其作为响应的内容返回给客户端。

需要注意的是，在使用@ResponseBody注解时，Spring会自动选择合适的HttpMessageConverter来将方法返回的对象转换为指定的格式（如JSON）。

希望以上信息可以满足你的需求。如果你还有其他问题，请随时提问！
未完…

　　天真

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
注解大全(笔记)

Component是Spring框架中的一个注解，用于将类标识为一个组件，让Spring容器管理该类的生命周期和依赖注入。当一个类被标注为@Component时，Spring会自动扫描并将该类实例化，并将其纳入到Spring容器的管理和控制之下。通过使用@Autowired等注解，可以方便地实现对其他组件的依赖注入。@Component是一个通用的组件注解，可以用于任何类。在实际使用中，一般还有一些特定的子注解，如@Service等，用于标识特定类型的组件。这些子注解继承了@Component。
复制链接

扫一扫

专栏目录