日常学习与工作中常见的注解(下)

在我们使用SpringBoot中比较常见的注解，提供学习时的查阅方便

[TOC]

部分如下

26）@ControllerAdvice

作⽤：⽤于全局处理异常。 @ControllerAdvice是Spring框架中的⼀个注解，⽤于定义全局控制器通知。在Spring MVC框架中，控制器通知是⼀些特殊的组件，它们可以在控制器⽅法执⾏前、执⾏后或抛出异常时执⾏⼀些额外的逻辑处理。使⽤@ControllerAdvice注解可以定义全局控制器通知，它可以应⽤于所有的控制器。

eg:

public class test {
    @ControllerAdvice
    public class GlobalControllerAdvice {
        @ModelAttribute("currentUser")
        public User getCurrentUser() {
            // 获取当前登录⽤户信息
            User currentUser = userService.getCurrentUser();
            return currentUser;
        }
        @InitBinder
        public void initBinder(WebDataBinder binder) {
            // 注册⾃定义的属性编辑器
            binder.registerCustomEditor(Date.class, new CustomDateEditor(new S
                    impleDateFormat("yyyy-MM-dd"), true));
        }
        @ExceptionHandler(Exception.class)
        public ModelAndView handleException(Exception ex) {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("errorMessage", ex.getMessage());
            modelAndView.setViewName("error");
            return modelAndView;
        }
    }
}

这个类使⽤@ControllerAdvice注解标注，表示这个类是⼀个全局控制器通知。

在⽅法级别上，使⽤ @ModelAttribute注解标注⽅法，表示这个⽅法会在所有控制器⽅法执⾏前执⾏，⽤于将当前登录⽤户信息添加到模型中。

使⽤@InitBinder注解标注⽅法，表示这个⽅法会在所有控制器⽅法执⾏前执⾏，⽤于注册⾃定义的属性编辑器。

使⽤@ExceptionHandler注解标注⽅法，表示这个⽅法会在控制器中抛出异常时执⾏，⽤于处理控制器⽅法中抛出的异常。

@ControllerAdvice注解⽤于定义全局控制器通知，使得开发者可以在所有控制器⽅法执⾏前、执⾏后或抛出异常时执⾏⼀些额外的逻辑处理。同时，使⽤@ModelAttribute注解可以将⼀些公共的模型数据添加到模型中，使⽤@InitBinder注解可以注册⾃定义的属性编辑器，使⽤@ExceptionHandler注解可以处理控制器⽅法中抛出的异常。

@ControllerAdvice注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地定义全局控制器通知。

27）@CrossOrigin

作⽤：⽤于解决跨域问题。

@CrossOrigin是Spring框架中的⼀个注解，⽤于解决跨域资源共享（CORS）问题。

跨域资源共享是浏览器安全策略的⼀部分，它限制了浏览器在不同域名之间发送和接收HTTP请求。使⽤ @CrossOrigin注解可以指定允许跨域访问的域名和HTTP⽅法。

eg:

@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://localhost:8080", methods = {RequestMethod.G
        ET, RequestMethod.POST})
public class ApiController {
    @GetMapping("/users")
    public List<User> getUsers() {
        // 查询⽤户信息
        List<User> users = userService.getUsers();
        return users;
    }
}

这个类使⽤@RestController注解标注，表示这个类是⼀个RESTful⻛格的控制器。在类级别上，使⽤ @RequestMapping注解指定控制器处理的请求路径为/api。同时，使⽤@CrossOrigin注解可以指定允许跨域访问的域名和HTTP⽅法。

在这个例⼦中，使⽤@CrossOrigin注解指定允许来⾃http://localhost:8080域名的GET和POST请求访问该控制器中的⽅法。这意味着，在http://localhost:8080域名下的⽹⻚可以通过XMLHttpRequest对象发送GET和 POST请求，访问该控制器中的⽅法。

@CrossOrigin注解⽤于解决跨域资源共享（CORS）问题，使得开发者可以更加灵活地控制允许跨域访问的域名和HTTP⽅法。它是⼀种简单但⾮常有效的解决⽅案，可以使得前端开发者更加轻松地开发跨域应⽤程序。

@CrossOrigin注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地解决跨域资源共享（CORS）问题。

28）@Async

作⽤：⽤于将⽅法标记为异步执⾏。

在Spring框架中，如果⼀个⽅法需要执⾏⼀些⽐较耗时的操作，如果这个⽅法是在主线程中执⾏，就会导致主线程被阻塞，⽤户界⾯⽆法响应⽤户的操作。使⽤@Async注解可以将这个⽅法的执⾏异步化，让主线程继续执⾏其他任务，提⾼应⽤程序的响应性能。

eg:

@Service
public class UserService {
    @Async
    public CompletableFuture<UserDetails> getUserDetailsAsync(Long id) {
        // 查询⽤户信息
        UserDetails userDetails = userRepository.getUserDetails(id);
        return CompletableFuture.completedFuture(userDetails);
    }
}

这个类使⽤@Service注解标注，表示这个类是⼀个服务。

在⽅法级别上，使⽤@Async注解标注⽅法，表示这个⽅法需要异步执⾏。

在这个例⼦中，getUserDetailsAsync⽅法使⽤@Async注解标注，表示这个⽅法需要异步执⾏。查询⽤户信息的操作在异步线程中执⾏，不会阻塞主线程。同时，这个⽅法返回⼀个CompletableFuture对象，表示异步执⾏的结果。

@Async注解⽤于异步执⾏⽅法，可以提⾼应⽤程序的响应性能。它是⼀种简单但⾮常有效的解决⽅案，可以使得开发者更加轻松地编写并发应⽤程序。

@Async注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地异步执⾏⽅法。需要注意的是，异步执⾏的⽅法必须在⼀个独⽴的线程中执⾏，因此需要使⽤线程池来管理异步线程的执⾏。

29）@Cacheable

作⽤：⽤于缓存⽅法的返回值。

在Spring框架中，如果⼀个⽅法的返回结果是固定的，⽽且这个⽅法的执⾏⽐较耗时，我们可以使⽤ @Cacheable注解将这个⽅法的返回结果缓存起来，下次执⾏这个⽅法时直接从缓存中获取结果，避免重复执⾏。

eg:

@Service
public class UserService {
    @Cacheable("userCache")
    public User getUser(Long id) {
        // 查询⽤户信息
        User user = userRepository.getUser(id);
        return user;
    }
}

这个类使⽤@Service注解标注，表示这个类是⼀个服务。在⽅法级别上，使⽤@Cacheable注解标注⽅法，表示这个⽅法返回的结果可以被缓存起来。

在这个例⼦中，getUser⽅法使⽤@Cacheable注解标注，表示这个⽅法的返回结果可以被缓存起来。查询⽤户信息的操作在第⼀次执⾏时会被执⾏，返回结果会被缓存到名为"userCache"的缓存中。下次执⾏getUser⽅法时，如果缓存中已经存在这个结果，就直接从缓存中获取结果，不需要再次执⾏查询操作。

@Cacheable注解⽤于缓存⽅法的返回结果，可以提⾼应⽤程序的执⾏效率。它是⼀种简单但⾮常有效的解决⽅案，可以使得开发者更加灵活地使⽤缓存来优化应⽤程序的性能。

@Cacheable注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加轻松地使⽤缓存来提⾼应⽤程序的性能。需要注意的是，使⽤缓存需要考虑缓存的⽣命周期和缓存的⼀致性，必要时需要使⽤缓存失效机制和缓存更新机制来维护缓存的⼀致性。

30）@CacheEvict

作⽤：⽤于清除缓存。

@CacheEvict是Spring框架中的⼀个注解，⽤于清空缓存中的数据。

在Spring框架中，如果⼀个⽅法的执⾏会导致缓存数据的失效，我们可以使⽤@CacheEvict注解将这个⽅法的缓存数据清空，这样下次执⾏这个⽅法时就会重新查询数据并缓存起来。

eg:

@Service
public class UserService {
    @Cacheable("userCache")
    public User getUser(Long id) {
        // 查询⽤户信息
        User user = userRepository.getUser(id);
        return user;
    }
    @CacheEvict("userCache")
    public void clearCache() {
        // 清空缓存
    }
}

这个类使⽤@Service注解标注，表示这个类是⼀个服务。在⽅法级别上，使⽤@Cacheable注解标注getUser⽅法，表示这个⽅法的返回结果可以被缓存起来。同时，使⽤@CacheEvict注解标注clearCache⽅法，表示这个⽅法会清空名为"userCache"的缓存。

当调⽤clearCache⽅法时，@CacheEvict注解会清空名为"userCache"的缓存，下次执⾏getUser⽅法时，就需要重新查询数据并缓存起来。

@CacheEvict注解⽤于清空缓存中的数据，可以使得开发者更加灵活地控制缓存的⽣命周期和缓存的⼀致性。它是⼀种简单但⾮常有效的解决⽅案，可以使得开发者更加轻松地使⽤缓存来提⾼应⽤程序的性能。

@CacheEvict注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地控制缓存的⽣命周期和缓存的⼀致性。需要注意的是，清空缓存需要谨慎操作，必要时需要考虑缓存的失效机制和缓存更新机制来维护缓存的⼀致性。

31）@CachePut

作⽤：⽤于更新缓存中的数据。

@CachePut是Spring框架中的⼀个注解，⽤于更新或添加缓存中的数据。

在Spring框架中，如果⼀个⽅法的执⾏会导致缓存数据的更新或添加，我们可以使⽤@CachePut注解将这个⽅法的返回结果更新或添加到缓存中。

eg:

@Service
public class UserService {
    @Cacheable("userCache")
    public User getUser(Long id) {
        // 查询⽤户信息
        User user = userRepository.getUser(id);
        return user;
    }
    @CachePut("userCache")
    public User updateUser(Long id, User user) {
        // 更新⽤户信息
        User updatedUser = userRepository.updateUser(id, user);
        return updatedUser;
    }
}

这个类使⽤@Service注解标注，表示这个类是⼀个服务。在⽅法级别上，使⽤@Cacheable注解标注getUser⽅法，表示这个⽅法的返回结果可以被缓存起来。同时，使⽤@CachePut注解标注updateUser⽅法，表示这个⽅法会更新或添加名为"userCache"的缓存。

当调⽤updateUser⽅法时，@CachePut注解会更新或添加名为"userCache"的缓存，下次执⾏getUser⽅法时，就可以从缓存中获取更新后的⽤户信息。

@CachePut注解⽤于更新或添加缓存中的数据，可以使得开发者更加灵活地控制缓存的⽣命周期和缓存的⼀致性。它是⼀种简单但⾮常有效的解决⽅案，可以使得开发者更加轻松地使⽤缓存来提⾼应⽤程序的性能。

@CachePut注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地控制缓存的⽣命周期和缓存的⼀致性。需要注意的是，更新或添加缓存需要谨慎操作，必要时需要考虑缓存的失效机制和缓存更新机制来维护缓存的⼀致性。

32）@Transactional

作⽤：⽤于启⽤事务管理功能。

@Transactional是Spring框架中的⼀个注解，⽤于标识⼀个⽅法或类需要使⽤事务进⾏操作。

在Spring框架中，如果⼀个⽅法需要对数据库进⾏操作，我们可以使⽤@Transactional注解来确保这个操作在⼀个事务中进⾏，从⽽保证操作的原⼦性、⼀致性、隔离性和持久性。

eg:

@Service
@Transactional
public class UserService {
    @Autowired
    private UserRepository userRepository;
    public void createUser(User user) {
        userRepository.save(user);
    }
    public void updateUser(Long id, User user) {
        User existingUser = userRepository.findById(id);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            existingUser.setEmail(user.getEmail());
            userRepository.save(existingUser);
        }
    }
}

这个类使⽤@Service注解标注，表示这个类是⼀个服务。同时，在类级别上使⽤@Transactional注解标注，表示这个类中的所有⽅法都需要使⽤事务进⾏操作。

在这个例⼦中，createUser和updateUser⽅法都需要对数据库进⾏操作，因此使⽤userRepository来保存或更新⽤户信息。由于这个类使⽤了@Transactional注解来标识，因此userRepository的操作都在⼀个事务中进⾏，从⽽保证操作的原⼦性、⼀致性、隔离性和持久性。

@Transactional注解⽤于标识⼀个⽅法或类需要使⽤事务进⾏操作，可以使得开发者更加灵活地控制事务的使⽤。它是⼀种简单但⾮常有效的解决⽅案，可以使得开发者更加轻松地使⽤事务来提⾼应⽤程序的性能和数据⼀致性。

@Transactional注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加灵活地控制事务的使⽤。需要注意的是，事务的使⽤需要谨慎操作，必要时需要考虑事务的隔离级别、超时时间和回滚机制等来维护数据的⼀致性和应⽤程序的性能。

33）@EnableAspectJAutoProxy

作⽤：⽤于启⽤AOP功能。

@EnableAspectJAutoProxy是Spring框架中的⼀个注解，⽤于启⽤⾃动代理功能，以便使⽤AOP（⾯向切⾯编程）进⾏编程。

在Spring框架中，如果需要使⽤AOP来实现某些功能，我们可以使⽤@EnableAspectJAutoProxy注解来启⽤⾃动代理功能，从⽽在运⾏时⾃动为我们⽣成代理对象，以便进⾏切⾯编程。

eg:

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public MyAspect myAspect() {
        return new MyAspect();
    }
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

这个类使⽤@Configuration注解标注，表示这个类是⼀个配置类。同时，在类级别上使⽤ @EnableAspectJAutoProxy注解标注，表示这个配置类需要启⽤⾃动代理功能。

在这个例⼦中，我们定义了⼀个MyAspect类来实现某些功能的切⾯编程。为了让Spring框架能够⾃动为我们⽣成代理对象，我们需要将MyAspect类加⼊到Spring容器中，并且使⽤@Bean注解标注。另外，我们还定义了⼀个UserService类来实现某些业务功能。

@EnableAspectJAutoProxy注解⽤于启⽤⾃动代理功能，可以使得开发者更加⽅便地使⽤AOP来实现某些功能。它是⼀种简单但⾮常有效的解决⽅案，可以让开发者更加轻松地使⽤切⾯编程来提⾼应⽤程序的性能和可维护性。

@EnableAspectJAutoProxy注解是Spring框架中⽐较常⽤的注解之⼀，可以让开发者更加⽅便地使⽤AOP来实现某些功能。需要注意的是，AOP的使⽤需要谨慎操作，必要时需要考虑AOP的切⾯逻辑、切⼊点和通知类型等来维护应⽤程序的性能和可维护性。

34）@Aspect

作⽤：⽤于定义切⾯。

@Aspect是Spring框架中的⼀个注解，⽤于标识⼀个类为切⾯类，从⽽可以在该类中定义切⾯逻辑以实现AOP （⾯向切⾯编程）。

在Spring框架中，如果需要使⽤AOP来实现某些功能，我们可以使⽤@Aspect注解来标识⼀个类为切⾯类。在切⾯类中，我们可以定义切⾯逻辑，包括切⼊点、通知类型和切⾯顺序等，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @Before("execution(* com.example.UserService.*(..))")
    public void beforeAdvice() {
        System.out.println("Before advice is executed.");
    }
    @After("execution(* com.example.UserService.*(..))")
    public void afterAdvice() {
        System.out.println("After advice is executed.");
    }
}

35）@Pointcut

作⽤：⽤于定义切点。

@Pointcut是Spring框架中的⼀个注解，⽤于定义⼀个切⼊点，从⽽可以在该切⼊点上定义通知类型以实现AOP （⾯向切⾯编程）。

在Spring框架中，如果需要使⽤AOP来实现某些功能，我们可以使⽤@Pointcut注解来定义⼀个切⼊点。在切⼊点上，我们可以定义切⾯逻辑，包括通知类型和切⾯顺序等，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @Pointcut("execution(* com.example.UserService.*(..))")
    public void userServicePointcut() {}
    @Before("userServicePointcut()")
    public void beforeAdvice() {
        System.out.println("Before advice is executed.");
    }
    @After("userServicePointcut()")
    public void afterAdvice() {
        System.out.println("After advice is executed.");
    }
}

这个类使⽤@Aspect注解标识，表示这个类是⼀个切⾯类。同时，我们还使⽤@Component注解标识这个类，以便Spring框架能够⾃动将它加⼊到Spring容器中。

在这个例⼦中，我们定义了⼀个MyAspect类来实现某些功能的切⾯编程。在这个类中，我们使⽤@Pointcut注解定义了⼀个切⼊点，即userServicePointcut()⽅法。在这个切⼊点上，我们定义了两个通知类型，即@Before 和@After，分别表示在⽬标⽅法执⾏前和执⾏后执⾏某些操作。

@Pointcut注解⽤于定义⼀个切⼊点，可以使得开发者更加⽅便地使⽤AOP来实现某些功能。它是⼀种简单但⾮常有效的解决⽅案，可以让开发者更加轻松地使⽤切⾯编程来提⾼应⽤程序的性能和可维护性。

@Pointcut注解是Spring框架中⽐较常⽤的注解之⼀，⽤于定义⼀个切⼊点。需要注意的是，AOP的使⽤需要谨慎操作，必要时需要考虑切⼊点、通知类型和切⾯顺序等来维护应⽤程序的性能和可维护性。

36）@Before

作⽤：⽤于在⽅法执⾏前执⾏通知。

@Before是Spring框架中的⼀个注解，⽤于定义在⽬标⽅法执⾏前执⾏的通知类型，以实现AOP（⾯向切⾯编程）。

在Spring框架中，如果需要在⽬标⽅法执⾏前执⾏某些操作，我们可以使⽤@Before注解来定义⼀个通知类型。在这个通知类型中，我们可以编写⾃⼰的逻辑代码，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @Before("execution(* com.example.UserService.*(..))")
    public void beforeAdvice() {
        System.out.println("Before advice is executed.");
    }
}

37）@After

作⽤：⽤于在⽅法执⾏后执⾏通知。

@After是Spring框架中的⼀个注解，⽤于定义在⽬标⽅法执⾏后执⾏的通知类型，以实现AOP（⾯向切⾯编程）。

在Spring框架中，如果需要在⽬标⽅法执⾏后执⾏某些操作，我们可以使⽤@After注解来定义⼀个通知类型。在这个通知类型中，我们可以编写⾃⼰的逻辑代码，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @After("execution(* com.example.UserService.*(..))")
    public void afterAdvice() {
        System.out.println("After advice is executed.");
    }
}

38）@Around

作⽤：⽤于在⽅法执⾏前后执⾏通知。

@Around是Spring框架中的⼀个注解，⽤于定义在⽬标⽅法执⾏前后执⾏的通知类型，以实现AOP（⾯向切⾯编程）。

在Spring框架中，如果需要在⽬标⽅法执⾏前后执⾏某些操作，我们可以使⽤@Around注解来定义⼀个通知类型。在这个通知类型中，我们可以编写⾃⼰的逻辑代码，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @Around("execution(* com.example.UserService.*(..))")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throw
    able {
        System.out.println("Before advice is executed.");
        Object result = joinPoint.proceed();
        System.out.println("After advice is executed.");
        return result;
    }
}

39）@AfterReturning

作⽤：⽤于在⽅法返回结果后执⾏通知。

@AfterReturning是Spring框架中的⼀个注解，⽤于定义在⽬标⽅法返回结果后执⾏的通知类型，以实现AOP （⾯向切⾯编程）。

在Spring框架中，如果需要在⽬标⽅法返回结果后执⾏某些操作，我们可以使⽤@AfterReturning注解来定义⼀个通知类型。在这个通知类型中，我们可以编写⾃⼰的逻辑代码，从⽽实现AOP编程的功能。

eg:

@Aspect
@Component
public class MyAspect {
    @AfterReturning(pointcut = "execution(* com.example.UserService.*
    (..))", returning = "result")
    public void afterReturningAdvice(Object result) {
        System.out.println("After returning advice is executed. Result is
                " + result);
    }
}

40）@Order

作⽤：⽤于指定切⾯的执⾏顺序。

@Order是Spring框架中的⼀个注解，⽤于定义切⾯的执⾏顺序。

在Spring框架中，如果有多个切⾯类需要对同⼀个⽅法进⾏切⾯处理，那么这些切⾯类的执⾏顺序可能会影响到最终的结果。为了控制这些切⾯类的执⾏顺序，我们可以使⽤@Order注解来定义它们的执⾏顺序。

@Order注解可以应⽤在切⾯类上，⽤于指定切⾯执⾏的顺序。它的参数为⼀个整数，数值越⼩表示优先级越⾼，数值相同时按照类名的⾃然顺序进⾏排序。

eg:

@Aspect
@Component
@Order(2)
public class MyAspect2 {
    @Before("execution(* com.example.UserService.*(..))")
    public void beforeAdvice() {
        System.out.println("Before advice from MyAspect2 is executed.");
    }
}

41）@Slf4j

作⽤：⽤于简化⽇志记录。

@Slf4j是Lombok框架中的⼀个注解，⽤于在Java类中⾃动⽣成⽇志记录器。

在Java开发中，⽇志记录是⾮常重要的⼀环，可以帮助我们更好地了解程序的运⾏情况，从⽽更好地进⾏调试和优化。通常情况下，我们需要⼿动引⼊⽇志框架（如Log4j、SLF4J等）并编写相应的⽇志记录代码。这些代码可能会⽐较繁琐，⽽且容易出现错误。为了简化这个过程，Lombok框架提供了⼀个@Slf4j注解，可以在Java类中⾃动⽣成⽇志记录器。

使⽤@Slf4j注解⾮常简单，只需要在Java类中添加这个注解即可。在使⽤时，我们可以直接使⽤log变量来记录⽇志，⽽不需要再引⼊其他的⽇志框架

eg:

@Slf4j
public class MyService {
    public void doSomething() {
        log.debug("This is a debug message.");
        log.info("This is an info message.");
        log.error("This is an error message.");
    }
}

在这个例⼦中，我们定义了⼀个MyService类，并使⽤@Slf4j注解来⾃动⽣成⽇志记录器。然后，在 doSomething()⽅法中，我们直接使⽤log变量来记录⽇志，⽽不需要再引⼊其他的⽇志框架。

需要注意的是，使⽤@Slf4j注解需要在编译器中安装Lombok插件，否则可能会出现编译错误。

另外，虽然 @Slf4j注解⾮常⽅便，但在实际应⽤中，我们还需要根据实际情况选择合适的⽇志框架，并编写相应的⽇志记录代码。总之，@Slf4j是Lombok框架中的⼀个注解，可以在Java类中⾃动⽣成⽇志记录器，从⽽简化⽇志记录的过程。它是⼀种极为⽅便的解决⽅案，可以提⾼应⽤程序的可维护性和可读性。

42）@Data

作⽤：⽤于⾃动⽣成JavaBean的getters、setters、toString、hashCode和equals⽅法。

@Data是Lombok框架中的⼀个注解，可以⾃动⽣成Java类的getter、setter、equals、hashCode和toString等⽅法。

在Java开发中，我们经常需要编写⼀些POJO类来表示数据结构。这些类通常包含⼀些成员变量，并且需要编写相应的getter、setter、equals、hashCode和toString等⽅法。这些⽅法通常是相似的，⽽且⽐较繁琐。为了简化这个过程，Lombok框架提供了⼀个@Data注解，可以⾃动⽣成这些⽅法。

使⽤@Data注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，我们可以直接访问类的成员变量，并且可以⾃动⽣成相应的getter、setter、equals、hashCode和toString等⽅法。

eg:

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
}

43）@NoArgsConstructor

作⽤：⽤于⽣成⽆参构造函数。

@NoArgsConstructor是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个⽆参构造⽅法。

在Java开发中，我们经常需要编写⼀些POJO类来表示数据结构。这些类通常包含⼀些成员变量，并且需要编写相应的构造⽅法。在某些情况下，我们可能需要编写⼀个⽆参构造⽅法，⽤于创建⼀个对象的实例。这个构造⽅法通常是简单的、⽆需参数的。为了简化这个过程，Lombok框架提供了⼀个@NoArgsConstructor注解，可以⾃动⽣成⼀个⽆参构造⽅法。

使⽤@NoArgsConstructor注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，我们可以直接创建对象的实例，⽽不需要⼿动编写⽆参构造⽅法。

eg:

@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
}

在这个例⼦中，我们定义了⼀个User类，并使⽤@NoArgsConstructor注解来⾃动⽣成⼀个⽆参构造⽅法。然后,在其他的Java类中，我们可以直接创建User对象的实例，⽽不需要⼿动编写⽆参构造⽅法。

需要注意的是，使⽤@NoArgsConstructor注解需要在编译器中安装Lombok插件，否则可能会出现编译错误。另外，虽然@NoArgsConstructor注解⾮常⽅便，但在实际应⽤中，我们还需要根据实际情况选择合适的构造⽅法，并编写相应的代码。

总之，@NoArgsConstructor是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个⽆参构造⽅法，从⽽简化Java开发的过程。它是⼀种极为⽅便的解决⽅案，可以提⾼应⽤程序的可维护性和可读性。

44）@AllArgsConstructor

作⽤：⽤于⽣成全参构造函数。

@AllArgsConstructor是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个全参构造⽅法。

在Java开发中，我们经常需要编写⼀些POJO类来表示数据结构。这些类通常包含⼀些成员变量，并且需要编写相应的构造⽅法。在某些情况下，我们可能需要编写⼀个全参构造⽅法，⽤于初始化所有成员变量。这个构造⽅法通常包含所有成员变量作为参数。为了简化这个过程，Lombok框架提供了⼀个@AllArgsConstructor注解，可以⾃动⽣成⼀个全参构造⽅法。

使⽤@AllArgsConstructor注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，我们可以直接创建对象的实例，并传⼊相应的参数，⽽不需要⼿动编写全参构造⽅法。

eg:

@AllArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
}

在这个例⼦中，我们定义了⼀个User类，并使⽤@AllArgsConstructor注解来⾃动⽣成⼀个全参构造⽅法。然后，在其他的Java类中，我们可以直接创建User对象的实例，并传⼊相应的参数，⽽不需要⼿动编写全参构造⽅法。

需要注意的是，使⽤@AllArgsConstructor注解需要在编译器中安装Lombok插件，否则可能会出现编译错误。另外，虽然@AllArgsConstructor注解⾮常⽅便，但在实际应⽤中，我们还需要根据实际情况选择合适的构造⽅法，并编写相应的代码。

总之，@AllArgsConstructor是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个全参构造⽅法，从⽽简化Java开发的过程。它是⼀种极为⽅便的解决⽅案，可以提⾼应⽤程序的可维护性和可读性。

45）@Builder

作⽤：⽤于⽣成Builder模式的构造函数。

@Builder是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个Builder模式的构造器。

在Java开发中，我们经常需要编写⼀些POJO类来表示数据结构。这些类通常包含⼀些成员变量，并且需要编写相应的构造⽅法。在某些情况下，我们可能需要编写⼀个Builder模式的构造器，⽤于⽅便地创建对象实例。

Builder模式是⼀种创建对象的设计模式，它可以通过链式调⽤的⽅式设置对象的属性，并最终创建⼀个不可变的对象。为了简化这个过程，Lombok框架提供了⼀个@Builder注解，可以⾃动⽣成⼀个Builder模式的构造器。

使⽤@Builder注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，我们可以使⽤链式调⽤的⽅式设置对象的属性，并最终创建⼀个不可变的对象。

eg:

@Builder
public class User {
    private Long id;
    private String name;
    private Integer age;
}

在这个例⼦中，我们定义了⼀个User类，并使⽤@Builder注解来⾃动⽣成⼀个Builder模式的构造器。然后，在其他的Java类中，我们可以使⽤链式调⽤的⽅式设置User对象的属性，并最终创建⼀个不可变的对象。

需要注意的是，使⽤@Builder注解需要在编译器中安装Lombok插件，否则可能会出现编译错误。另外，虽然 @Builder注解⾮常⽅便，但在实际应⽤中，我们还需要根据实际情况选择合适的构造⽅法，并编写相应的代码。

总之，@Builder是Lombok框架中的⼀个注解，⽤于⾃动⽣成⼀个Builder模式的构造器，从⽽简化Java开发的过程。它是⼀种极为⽅便的解决⽅案，可以提⾼应⽤程序的可维护性和可读性。

46）@EqualsAndHashCode

作⽤：⽤于⽣成hashCode和equals⽅法。

@EqualsAndHashCode是Lombok框架中的⼀个注解，⽤于⾃动⽣成equals()和hashCode()⽅法。

在Java开发中，我们经常需要⽐较两个对象是否相等，并且需要根据对象的属性⽣成⼀个hashCode值。为了简化这个过程，Lombok框架提供了⼀个@EqualsAndHashCode注解，可以⾃动⽣成equals()和hashCode()⽅法。

使⽤@EqualsAndHashCode注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，Lombok会根据类的属性⾃动⽣成equals()和hashCode()⽅法。如果两个对象的所有属性都相等，那么它们的equals()⽅法返回 true，并且它们的hashCode()⽅法返回相同的值。

eg:

@EqualsAndHashCode
public class User {
    private Long id;
    private String name;
    private Integer age;
}

47）@ToString

作⽤：⽤于⽣成toString⽅法。

@ToString是Lombok框架中的⼀个注解，⽤于⾃动⽣成toString()⽅法。

在Java开发中，我们经常需要将对象转换为字符串，以便于输出或⽇志记录。为了简化这个过程，Lombok框架提供了⼀个@ToString注解，可以⾃动⽣成toString()⽅法。

使⽤@ToString注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，Lombok会根据类的属性⾃动⽣成toString()⽅法，这个⽅法将输出类的名称和所有属性的名称和值。如果需要排除某些属性，可以使⽤ exclude属性来指定排除的属性。

eg:

@ToString(exclude = "password")
public class User {
    private Long id;
    private String name;
    private String password;
}

48）@Getter

作⽤：⽤于⽣成getters⽅法。

@Getter是Lombok框架中的⼀个注解，⽤于⾃动⽣成getter⽅法。

在Java开发中，我们经常需要为类的属性编写getter和setter⽅法。为了简化这个过程，Lombok框架提供了⼀个@Getter注解，可以⾃动⽣成getter⽅法。

使⽤@Getter注解⾮常简单，只需要在Java类上添加这个注解即可。在使⽤时，Lombok会根据类的属性⾃动⽣成对应的getter⽅法。如果需要⽣成setter⽅法，可以使⽤@Setter注解。

eg:

@Getter
public class User {
    private Long id;
    private String name;
    private Integer age;
}