【SpringBoot】开发常见注解

鹏阿鹏

于 2024-08-20 20:39:55 发布

阅读量345

点赞数 3

本文链接：https://blog.csdn.net/AwesomeP/article/details/140833092

版权

Java 同时被 3 个专栏收录

32 篇文章 1 订阅

订阅专栏

Spring Boot

4 篇文章 0 订阅

订阅专栏

Spring

2 篇文章 0 订阅

订阅专栏

Controller

@Controller

标识一个Spring MVC控制器，用于处理HTTP请求。

@RestController

@RestController 注解是 @Controller 和 @ResponseBody 两个注解的组合。@Controller 注解表明这个类是一个 Spring MVC 控制器，而 @ResponseBody 注解则表明控制器的方法返回值应该绑定到 web 响应体上。

@RestController 是 Spring Boot 中的一个非常核心的注解，它用于标注在类上，表明这个类是一个控制器（Controller），并且所有的方法返回值都会直接作为 HTTP 响应体返回给客户端，这通常用于构建 RESTful Web 服务。

@ResponseBody

@ResponseBody 是 Spring MVC 和 Spring Boot 中用于标注在控制器（Controller）的方法上的注解。它表明该方法的返回值应该直接作为 HTTP 响应体返回给客户端，而不是被解析为跳转路径或模板名称。

@Controller  
public class MyController {  
  
    @GetMapping("/hello")  
    @ResponseBody  
    public String hello() {  
        return "Hello, Spring MVC!";  
    }  
}

@GetMapping 与 @PostMapping

@GetMapping 和 @PostMapping 是用于处理 HTTP GET 和 POST 请求的注解。它们分别对应于 HTTP 协议中的 GET 和 POST 方法，常用于构建 RESTful Web 服务。

@RestController  
public class MyController {  
  
    @GetMapping("/hello")  
    public String hello() {  
        return "Hello, GET request!";  
    }
    @PostMapping("/submit")  
    public String submit(@RequestParam String data) {  
        // 处理提交的数据  
        return "Received data: " + data;  
    }  
}

@RequestMapping

@RequestMapping用于处理 HTTP 请求的注解。它可以标注在类或方法上，用于将 HTTP 请求映射到特定的处理方法上。

@Controller
@RequestMapping("/users")  
public class UserController {  
  
    @RequestMapping(value = "/{userId}", method = RequestMethod.GET)  
    public String getUser(@PathVariable("userId") String userId, Model model) {  
        // 处理 GET 请求，路径如 /users/{userId}  
        return "user";  
    }  
  
    @RequestMapping(value = "/new", method = RequestMethod.GET)  
    public String newUserForm(Model model) {  
        // 处理 GET 请求，路径如 /users/new  
        return "userForm";  
    }  
}

@RequestParam

@RequestParam将HTTP请求中的查询参数或表单参数绑定到控制器方法的参数上。
如果你有一个请求URL为/user?name=John，那么使用@RequestParam(“name”) String userName可以将查询参数name的值John绑定到方法参数userName上。

@PathVariable

@PathVariable将URL模板变量值绑定到控制器方法的参数上。这通常用于RESTful风格的URL，其中URL的一部分表示资源的标识符。
如果你有一个请求URL为/users/123，并且控制器方法定义为@GetMapping(“/users/{userId}”)，那么使用@PathVariable(“userId”) String userId可以将URL模板变量userId的值123绑定到方法参数userId上。

@RequestBody

@RequestBody将HTTP请求体的内容绑定到控制器方法的参数上。这通常用于处理客户端发送的JSON或XML数据。
如果你有一个请求体为{“name”:“John”, “age”:30}的POST请求，并且控制器方法定义为@PostMapping(“/user”)，那么使用@RequestBody User user可以将请求体中的JSON数据绑定到方法参数user上，其中User是一个具有name和age属性的Java类。

@RestController  
@RequestMapping("/api")  
public class MyController {  
  
    // 使用@RequestParam绑定查询参数  
    @GetMapping("/greeting")  
    public ResponseEntity<String> greeting(@RequestParam(name = "name", defaultValue = "World") String name) {  
        return ResponseEntity.ok("Hello, " + name + "!");  
    }  
  
    // 使用@PathVariable绑定URL模板变量  
    @GetMapping("/users/{userId}")  
    public ResponseEntity<String> getUser(@PathVariable("userId") String userId) {  
        return ResponseEntity.ok("User ID: " + userId);  
    }  
  
    // 使用@RequestBody绑定请求体内容  
    @PostMapping("/user")  
    public ResponseEntity<String> createUser(@RequestBody User user) {  
        // 假设User是一个具有name和age属性的Java类  
        return ResponseEntity.ok("User created: " + user.getName() + ", " + user.getAge());  
    }  
}

@Valid

@Valid注解在 Spring 框架中用于开启对方法参数或返回值的自动验证，通常与 @NotNull、@Size等一起使用以验证 Java Bean 的属性。

@RestController  
@RequestMapping("/api")  
public class ValidationController {  
  
    @PostMapping("/create")  
    public ResponseEntity<String> createItem(@Valid @RequestBody Item item) {  
        // 如果验证通过，则处理数据  
        return ResponseEntity.ok("Item created: " + item.getName());  
    }  
  
    public static class Item {  
        @NotBlank(message = "Name is required and cannot be blank")  
        private String name;  
        @Min(1)  
        private int quantity;  
        // 省略构造函数、getter和setter方法  
    }  
}

Service

@Service

@Service 注解主要用于标记业务逻辑层的服务组件。这个注解是 @Component 的一个特化版本，用于指示一个类应该被视为Spring应用上下文中的一个Bean。当Spring进行组件扫描时，它会自动检测并实例化所有带有 @Service 注解的类，并将它们注入到依赖于这些服务的其他Bean中。

@Autowired

@Autowired 用于实现依赖注入，可以用在变量、构造方法、setter 方法上。Spring 在进行依赖注入时，会先尝试按类型（byType）进行匹配，如果找到多个相同类型的 Bean，则会按名称（byName）进行匹配。

@Service  
public class UserService {   
    @Autowired  
    private UserRepository userRepository;  
    // 使用 userRepository 的方法...  
}

@Resource

@Resource 用于实现依赖注入。

虽然@Autowired和@Resource都用于依赖注入，但它们在细节上存在一些差异：

来源：@Autowired是Spring框架提供的注解，而@Resource是Java EE 5引入的标准注解，Spring框架也支持它。
默认行为：@Autowired默认按类型进行注入，可以通过@Qualifier注解指定名称；@Resource默认按名称进行注入，如果未指定名称，则按字段名或setter方法名进行查找，如果还是找不到，则按类型查找。
灵活性：@Resource注解在灵活性方面略胜一筹，因为它同时支持按名称和按类型进行注入。

@Scheduled

@Scheduled注解用于在应用程序中定义定时任务。它允许你以声明式的方式定义需要周期性执行的方法。@Scheduled注解可以接受多个参数来自定义调度策略，其中initialDelay和fixedRate就是两个常用的参数。

initialDelay: 设定第一次执行任务前的延迟时间，单位是毫秒。例如，initialDelay = 360000L意味着第一次执行这个定时任务将在360秒（即360000毫秒）之后开始。
fixedRate: 一个固定的时间间隔（毫秒），从上一次任务的完成到下一次任务的开始。例如，fixedRate = 300000L意味着每次任务执行完成后，下一次执行将在5分钟后（即300000毫秒）开始。
cron: 一个 cron 表达式，用于定义任务的执行频率。cron 表达式是一个字符串，由六个或七个空格分隔的字段组成，分别代表秒、分、小时、日、月、周和年（可选）。例如 “0 0 12 * * ?” 表示每天中午12点执行。
fixedDelay: 类似于 fixedRate，但是计算间隔是从上一次任务的开始到下一次任务的开始。

注意事项：1.如果一个方法同时使用了 cron 和 fixedRate 或 fixedDelay，那么 cron 将会优先级更高。2.使用 fixedRate 或 fixedDelay 时，如果方法的执行时间超过设定的间隔，那么下一次执行将被推迟，直到当前执行完成。3.任务的执行是在后台线程中进行的，因此不会阻塞应用程序的主线程。

@Service
public class ScheduledTasks {

    @Scheduled(cron = "0 0 * * * ?")
    public void scheduledMethod() {
        // 你的任务代码
    }
}

在Spring Boot中启用@Scheduled注解需要在配置类上添加@EnableScheduling注解。一旦你添加了@EnableScheduling，你就可以在任何bean类中使用@Scheduled注解来定义定时任务。

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

@Configuration
@EnableScheduling
public class AppConfig {
    // 其他配置代码...
}

@Async

@Async 是 Spring 框架中的一个注解，用于在 Spring 应用程序中轻松地实现异步方法调用。通过使用 @Async，你可以将方法标记为异步执行，从而提高应用程序的响应性和性能。

用途：

异步方法调用：将长时间运行的任务放在后台线程中执行，以避免阻塞主线程。
提高应用性能：通过将耗时的任务异步执行，可以显著提高应用程序的响应速度和吞吐量。
解耦任务执行：将任务提交给异步执行器，而不关心具体的执行细节。

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;

@Service
@EnableAsync
public class AsyncService {

    @Async
    public void doSomethingAsync() {
        try {
            Thread.sleep(5000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Finished executing asynchronously");
    }
}

为了启用异步支持, 需要使用 @EnableAsync 启用异步支持

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(4);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("Async-Executor-");
        executor.initialize();
        return executor;
    }
}

指定异步执行器：

定义执行器

@Configuration  
@EnableAsync  
public class AsyncConfig {  
  
    @Bean(name = "deleteCosExecutor")  
    public Executor deleteCosExecutor() {  
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(5);  
        executor.setMaxPoolSize(10);  
        executor.setQueueCapacity(25);  
        executor.initialize();  
        return executor;  
    }  
}

异步注解使用自定义执行器

@Service  
public class SomeService {  
  
    @Async("deleteCosExecutor")  
    public void deleteSomethingAsync() {  
        // 这里是异步执行的代码  
        System.out.println("Deleting something asynchronously...");  
        // 模拟耗时操作  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            Thread.currentThread().interrupt();  
        }  
    }  
}

Entity

@Data

@Data 是 Lombok 库提供的一个非常实用的注解，它能够极大地减少在 Java 类中编写 getter、setter、toString、equals 和 hashCode 方法的样板代码。当你在一个类上使用 @Data 注解时，Lombok 会基于类中的字段自动生成这些方法。

@Data 注解是以下多个 Lombok 注解的组合：

@Getter：为所有非静态字段生成 getter 方法。
@Setter：为所有非静态字段生成 setter 方法。
@RequiredArgsConstructor：为所有被 @NonNull 标记的构造器参数生成构造器。
@ToString：生成toString 方法。
@EqualsAndHashCode：生成 equals 和 hashCode 方法。

@Data
public class Person {
    private String name;
    private int age;
    private boolean active;
}

@JsonFormat

@JsonFormat 是一个属于 Jackson 库的注解，是一个流行的 Java JSON 处理库。Jackson 用于将 Java 对象序列化成 JSON 字符串（也称为“写入”或“序列化”），以及将 JSON 字符串反序列化成 Java 对象（也称为“读取”或“反序列化”）。

@JsonFormat 注解允许你自定义 Java 对象中的属性如何被序列化和反序列化成 JSON。这包括日期时间格式、空值处理、模式匹配等。

@JsonFormat(pattern=“yyyy-MM-dd HH:mm:ss”,timezone=“Asia/Shanghai”)

import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;

public class Event {

    private String name;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date eventTime;

    // getters and setters
}

@ToString

@ToString 是 Lombok 库中的一个注解，用于自动生成类的 toString() 方法。

@TableName(“xxx”)

@TableName 是 MyBatis Plus 中的一个注解，用于指定映射到数据库表的实体类所对应的表名。这个注解通常用在实体类上，以明确指出该实体类与哪个数据库表相对应。

@TableField

@TableField 是 MyBatis Plus 中的一个注解，用于指定实体类中的字段与数据库表中的字段之间的映射关系。

除了指定字段映射之外，@TableField 注解还支持其他配置选项。以下是一些常见的配置：

exist：指定字段是否存在于数据库表中。默认为 true。
fill：指定字段的填充策略，例如 INSERT（插入时填充）、UPDATE（更新时填充）等。
el：表达式语言，用于动态生成字段值。
select：查询时的 SQL 片段。
update：更新时的 SQL 片段。

import com.baomidou.mybatisplus.annotation.IdType;  
import com.baomidou.mybatisplus.annotation.TableField;  
import com.baomidou.mybatisplus.annotation.TableId;  
import com.baomidou.mybatisplus.annotation.TableName;  
  
@TableName("user") // 指定实体类对应的数据库表名  
public class User {  
  
    @TableId(type = IdType.AUTO) // 指定主键，并设置主键生成策略为自增  
    private Long id;  
  
    @TableField("name") // 指定Java对象属性对应数据库表的字段名，如果Java属性名和数据库字段名一致，则可以省略该注解  
    private String name;  
  
    @TableField("age")  
    private Integer age;  
  
    // 如果Java属性名和数据库字段名不一致，则需要使用@TableField注解明确指定  
    @TableField("email_address")  
    private String email;  
  
    // 省略getter和setter方法  
    // ...  
}

@ApiModel(“xxx对象”)

@ApiModel是一个用于生成 API 文档的注解，它属于 Swagger（现在称为 OpenAPI）规范的一部分。Swagger 是一个用于生成、描述、调用和可视化 RESTful 服务的框架。@ApiModel注解用来描述一个模型（通常是一个 POJO 类），它提供了关于模型的元数据，例如模型的描述和属性。

import io.swagger.annotations.ApiModel;  
import io.swagger.annotations.ApiModelProperty;  
  
@ApiModel(value = "xxx对象", description = "这是一个xxx对象的描述，包含了xxx的相关信息")  
public class XxxObject {  
  
    @ApiModelProperty(value = "ID", example = "123")  
    private Long id;  
  
    @ApiModelProperty(value = "名称", example = "示例名称")  
    private String name;  
  
    // 省略getter和setter方法  
}

@Accessors(chain = true)

@Accessors(chain = true) 是 Lombok 库中的一个注解，用于简化 Java 类中 getter 和 setter 方法的编写。当你在类上应用此注解时，Lombok 会在编译时自动生成 getter 和 setter 方法，并且这些方法可以链式调用。

import lombok.Accessors;
import lombok.Data;

@Data
@Accessors(chain = true)
public class Person {
    private String name;
    private int age;
    private String address;
}

链式调用:

public class Main {
    public static void main(String[] args) {
        Person person = new Person()
            .setName("Alice")
            .setAge(30)
            .setAddress("123 Main St.");

        System.out.println(person);
    }
}

DAO

@Repository

主要用于标记数据访问层（DAO层）的组件。

@Mapper

用于指示接口应该被 MyBatis 作为映射器（Mapper）处理的注解。

识别 Mapper 接口：
当你在一个接口上使用 @Mapper 注解，MyBatis 和 Spring 就知道这个接口是一个 Mapper，它会被自动扫描并注册到 Spring 容器中作为一个 Bean。
自动创建 Mapper 实现：
MyBatis 会为带有 @Mapper 注解的接口自动生成一个实现类。这个实现类通过动态代理机制创建，并且实现了接口中定义的所有方法。
避免 XML 映射文件：
从 MyBatis 3.4.0 版本开始，你可以完全不使用 XML 映射文件，而是在接口的方法上使用注解来定义 SQL 查询和其他数据库操作。
动态 SQL 支持：
你可以在接口方法上使用如 @Select, @Insert, @Update, @Delete 等注解来定义 SQL 语句。对于更复杂的动态 SQL，还可以使用 @SelectProvider 或 @UpdateProvider 等注解配合提供者类和方法来生成 SQL。

import org.apache.ibatis.annotations.*;

// 使用@Mapper注解表明这是一个MyBatis的Mapper接口
@Mapper
public interface UserMapper {

    // 定义一个查询所有用户的SQL语句
    @Select("SELECT * FROM user")
    List<User> findAllUsers();

    // 定义一个根据ID查询用户的SQL语句
    @Select("SELECT * FROM user WHERE id = #{id}")
    User findUserById(@Param("id") int id);

    // 定义一个插入新用户的SQL语句
    @Insert("INSERT INTO user (name, email) VALUES (#{name}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertUser(User user);

    // 定义一个更新用户信息的SQL语句
    @Update("UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}")
    void updateUser(User user);

    // 定义一个删除用户的SQL语句
    @Delete("DELETE FROM user WHERE id = #{id}")
    void deleteUser(@Param("id") int id);
}
// 假设User类如下
public class User {
    private int id;
    private String name;
    private String email;
    // 构造函数，getters和setters省略...
}

配置

@Configuration

@Configuration 是 Spring 框架中的一个注解，用于定义 Spring 配置类。它用于替代 XML 配置文件，使你可以通过 Java 代码来定义 Spring 应用程序的配置。

主要用途：

定义 Bean：通过@Bean方法定义 Spring 容器中的 Bean。
导入其他配置类：使用 @Import 注解导入其他的配置类。
启用自动扫描：使用 @ComponentScan 注解来指定 Spring 自动扫描的包，从而发现和注册带有相应注解的类（如 @Service, @Repository, @Controller 等）作为 Spring Bean。

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

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    // 其他 @Bean 方法...
}

@ComponentScan

@ComponentScan是 Spring 框架中的一个注解，用于指定 Spring IoC 容器自动扫描的包，从而发现和注册带有特定注解的类作为 Spring Bean。这使得你可以以声明式的方式管理组件，而不是手动定义每一个 Bean。

用途：

自动发现组件：Spring 会自动查找并注册标注了 @Component, @Service, @Repository, @Controller, @RestController 等注解的类作为 Spring Bean。
减少显式配置：通过使用 @ComponentScan，你可以减少在配置文件中显式定义 Bean 的需求，从而简化配置。
灵活的扫描选项：可以指定扫描的包、排除的包、扫描的模式等。


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

@Configuration
@ComponentScan(basePackages = {"com.example.service"})
public class AppConfig {
    // 其他配置...
}

@Component

@Component 注解用于标记一个类可以被Spring的IoC（控制反转）容器管理为一个“bean”。这意味着Spring可以自动创建这个类的实例并管理其生命周期。

@Bean

@Bean 是 Spring 框架中的一个注解，用于在配置类中定义和注册 bean。当在方法上使用 @Bean 注解时，该方法会被 Spring 容器识别，并将其返回的对象注册为一个 bean。这个 bean 将被管理并可以注入到其他 bean 中。

@Configuration // @Bean 注解通常与 @Configuration 注解一起使用。
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

在下面的例子中，myService() 方法依赖于 Dependency 类型的 bean。Spring 会首先调用 dependency() 方法来创建并注册 Dependency 类型的 bean，然后将它注入到 myService() 方法中，以便你可以将它传递给 MyServiceImpl 实例。

@Configuration  
public class AppConfig {  
  	
  	// myService bean依赖于dependency bean，而Spring会自动处理这些依赖关系，确保在创建MyServiceImpl实例时，Dependency 已经准备好并可以使用。
    @Bean  
    public MyService myService(Dependency dependency) {  
        MyServiceImpl myService = new MyServiceImpl();  
        myService.setDependency(dependency);  
        return myService;  
    }  
  
    @Bean  
    public Dependency dependency() {  
        return new Dependency();  
    }  
}

@PostConstruct

用于标记在依赖注入完成后执行的方法。

/*
使用了 Spring 的 @Component 注解来将 MySpringComponent 注册为 Spring Bean。Spring 容器会自动检测到 @PostConstruct 注解，并在依赖注入完成后调用 initializeConnection 方法。
*/
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

@Component
public class MySpringComponent {

    private Connection connection;

    public MySpringComponent(Connection connection) {
        this.connection = connection;
    }
	// @PostConstruct 方法应该是 void 类型的，不接受任何参数。
    @PostConstruct
    public void initializeConnection() {
        // 初始化连接
        connection.initialize();
        System.out.println("Connection initialized.");
    }

    // 其他方法...
}

@Conditional

@Conditional 是 Spring 框架中的一个注解，用于根据一定的条件决定是否注册一个 Bean。这使得你可以根据应用程序的环境或配置动态地决定哪些 Bean 应该被创建和注册到 Spring 容器中。

用途：

条件化 Bean 注册：根据不同的条件（如系统属性、环境变量、类是否存在等）来决定是否注册一个 Bean。
依赖检查：检查特定的类或 Bean 是否存在，从而决定是否注册另一个 Bean。
配置选择：根据不同的环境配置（如开发、测试、生产环境）来选择不同的 Bean 实现。

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

@Configuration
public class ConditionalConfig {

    @Bean
    @Conditional(OnWindowsCondition.class)
    public Service windowsService() {
        return new WindowsServiceImpl();
    }

    @Bean
    @Conditional(OnLinuxCondition.class)
    public Service linuxService() {
        return new LinuxServiceImpl();
    }
}

// 条件类
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
// Condition 接口需要实现 matches 方法，该方法接收两个参数：
// - ConditionContext：提供了访问 Spring 应用上下文的方法，可以获取环境变量、类路径资源等。
// - AnnotatedTypeMetadata：提供了访问元数据的方法，可以获取注解信息等。
public class OnWindowsCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("os.name").toLowerCase().contains("windows");
    }
}

public class OnLinuxCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("os.name").toLowerCase().contains("linux");
    }
}

@ConfigurationProperties

@ConfigurationProperties 是 Spring Boot 提供的一个非常有用的注解，它用于将配置文件中的属性绑定到 Java Bean 上。通过使用 @ConfigurationProperties，开发者可以很方便地将 application.properties 或 application.yml 文件中的配置项映射到 Java 类的字段上，进而在 Spring 应用程序中使用这些配置项。

application.properties 文件：

myapp.name=MyApplication  
myapp.description=This is my application's description

在类中绑定属性：

import org.springframework.boot.context.properties.ConfigurationProperties;  
import org.springframework.stereotype.Component;  
  
@Component  
@ConfigurationProperties(prefix = "myapp")  
public class MyAppConfig {  
  
    private String name;  
    private String description;  
  
    // getters and setters 省略
}

其他

@Slf4j

@Slf4j 是 Lombok 库中的一个注解，它用于简化在 Java 类中创建 Logger 对象的过程。

在没有 Lombok 的情况下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExampleClass {
    private static final Logger logger = LoggerFactory.getLogger(ExampleClass.class);
    
    public void someMethod() {
        logger.info("This is an info message.");
    }
}

然而，使用 Lombok 的 @Slf4j 注解，可以自动为类生成 logger 成员变量，而不需要手动写这段代码。只需要在你的类定义上添加@Slf4j注解，Lombok 就会在编译时为你生成相应的 Logger 实例。因此，上面的代码可以简化为：

@Slf4j
public class ExampleClass {
    public void someMethod() {
        // 注意这里的logger已经由Lombok自动生成了
        logger.info("This is an info message.");
    }
}