package top.rem.rain.springboot3demo;

import org.springframework.boot.SpringApplication;

@SpringBootApplication

public class SpringBoot3DemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(SpringBoot3DemoApplication.class, args);

    }

}

package top.rem.rain.springboot3demo;

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

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

@RestController

public class HelloController {

    @GetMapping("/hello")

    public String hello() {

        return "Hello, World!";

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @GetMapping("/users")

    public List<User> getUsers() {

        // 获取用户列表

    }

    @PostMapping("/users")

    public void createUser(@RequestBody User user) {

        // 创建新用户

    }

    @GetMapping("/users/{id}")

    public User getUserById(@PathVariable Long id) {

        // 根据 ID 获取用户信息

    }

    @PutMapping("/users/{id}")

    public void updateUser(@PathVariable Long id, @RequestBody User user) {

        // 更新用户信息

    }

    @DeleteMapping("/users/{id}")

    public void deleteUser(@PathVariable Long id) {

        // 根据 ID 删除用户

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @GetMapping("/users")

    public List<User> getUsers() {

        // 获取用户列表

    }

    @GetMapping("/users/{id}")

    public User getUserById(@PathVariable Long id) {

        // 根据 ID 获取用户信息

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @PostMapping("/users")

    public void createUser(@RequestBody User user) {

        // 创建新用户

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @PutMapping("/users/{id}")

    public void updateUser(@PathVariable Long id, @RequestBody User user) {

        // 更新用户信息

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @DeleteMapping("/users/{id}")

    public void deleteUser(@PathVariable Long id) {

        // 根据 ID 删除用户

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @GetMapping("/users")

    public List<User> getUsers(@RequestParam("page") int page, @RequestParam("size") int size) {

        // 分页获取用户列表

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @GetMapping("/users/{id}")

    public User getUser(@PathVariable Long id) {

        // 根据 ID 获取用户信息

    }

}

package top.rem.rain.springboot3demo;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api")

public class UserController {

    @PostMapping("/users")

    public User createUser(@RequestBody User user) {

        // 创建用户

    }

}

@RestController

public class UserController {

    @GetMapping("/users/{id}")

    @ResponseBody

    public User getUser(@PathVariable int id) {

        // 从数据库或其他地方获取用户数据

        User user = userService.getUserById(id);

        return user;

    }

}

@Service

public class UserServiceImpl implements UserService {

    @Autowired

    private UserRepository userRepository;

    // 实现 UserService 接口中的方法

}

@Component

public class UserServiceImpl implements UserService {

    // 实现 UserService 接口中的方法

}

@Service

public class UserServiceImpl implements UserService {

    // 实现 UserService 接口中的方法

}

@Repository

public class UserRepositoryImpl implements UserRepository {

    // 实现 UserRepository 接口中的方法

}

@Configuration

public class AppConfig {

    @Bean

    public UserService userService() {

        return new UserServiceImpl();

    }

    @Bean

    public UserRepository userRepository() {

        return new UserRepositoryImpl();

    }

}

/**

 * 这个类使用 @Component 注解标注，表示这个类是一个 Spring Bean，可以被其他的 Spring Bean 自动装配。

 * 在属性级别上，@Value 注解指定了需要注入的属性值，这个属性值可以通过 ${...} 的方式引用配置文件中的属性值。

 * 在这个例子中，MyComponent 类中的 myProperty 属性使用 @Value 注解指定了需要注入的属性值，Spring 会自动将配置文件中名为 my.property 的属性值注入到这个属性中。

 * @Value 注解用于注入配置文件中的属性值，使得开发者可以方便地从配置文件中获取属性值，并将其注入到 Bean 对象中。同时，使用 @Value 注解还可以方便地处理不同环境下的配置文件，如开发环境和生产环境的配置文件。

 * Value 注解是 Spring 框架中比较常用的注解之一，可以让开发者更加专注于业务逻辑的实现，而不必关心属性值的获取和注入细节。

 */

@Component

public class MyComponent {

    @Value("${my.property}")

    private String myProperty;

    // 其他方法

}

@Configuration

public class AppConfig {

    @Bean

    public UserService userService() {

        return new UserServiceImpl();

    }

    @Bean

    public UserRepository userRepository() {

        return new UserRepositoryImpl();

    }

}

@Configuration

@Import({AppConfig1.class, AppConfig2.class})

public class AppConfig {

    // 其他方法

}

@Configuration

public class AppConfig {

    @Bean

    @Conditional(DatabaseTypeCondition.class)

    public UserRepository userRepository() {

        return new UserRepositoryImpl();

    }

    // 其他方法

}

@Configuration

public class AppConfig {

    @Bean

    @Profile("dev")

    public UserService userServiceDev() {

        return new UserServiceDevImpl();

    }

    @Bean

    @Profile("prod")

    public UserService userServiceProd() {

        return new UserServiceProdImpl();

    }

    // 其他方法

}

/**

 * 这个类使用 @Configuration 注解标注，表示这个类是一个配置类，用于配置应用程序的 Bean 对象。

 * 在类级别上，使用 @PropertySource 注解可以指定一个属性文件的位置。在这个例子中，使用 @PropertySource 注解指定了一个名为 application.properties 的属性文件，它位于 classpath 下。

 * 在方法级别上，使用 @Bean 注解标注方法，表示这个方法返回一个 Bean 对象。在这个例子中，使用 Environment 对象从属性文件中读取属性值，并将这些属性值传递给 UserService 实例的构造方法。

 * @PropertySource 注解用于指定一组属性文件的位置，使得开发者可以在 Spring 应用程序中使用这些属性。同时，使用 Environment 对象可以方便地读取属性文件中的属性值，并将这些属性值传递给 Bean 对象的构造方法或属性。

 * @PropertySource 注解是 Spring 框架中比较常用的注解之一，可以让开发者更加灵活地管理和配置 Spring Bean。

 */

@Configuration

@PropertySource("classpath:application.properties")

public class AppConfig {

    @Autowired

    private Environment environment;

    @Bean

    public UserService userService() {

        return new UserServiceImpl(environment.getProperty("userService.name"));

    }

    // 其他方法

}

@Component

public class UserServiceImpl implements UserService {

    @Autowired

    @Qualifier("userRepositoryImpl")

    private UserRepository userRepository;

    // 其他方法

}

/**

 * 这个类使用 @ControllerAdvice 注解标注，表示这个类是一个全局异常处理器。在方法级别上，使用 @ExceptionHandler 注解可以指定一个方法来处理控制器中抛出的异常。

 * 在这个例子中，使用 @ExceptionHandler 注解指定了一个名为 handleException 的方法，它处理所有类型的异常。当控制器中抛出异常时，会调用这个方法，并将异常对象作为参数传递给这个方法。

 * 在这个方法中，使用 ModelAndView 对象来封装错误信息，并将视图名称设置为 error。最后，返回这个 ModelAndView 对象，将错误信息显示到用户界面上。

 * @ExceptionHandler 注解用于处理控制器中抛出的异常，使得开发者可以根据需要灵活地处理异常。同时，使用 @ControllerAdvice 注解可以将这个异常处理器应用于所有的控制器中。

 * @ExceptionHandler 注解是 Spring 框架中比较常用的注解之一，可以让开发者更加灵活地处理控制器中的异常。

 */

@ControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)

    public ModelAndView handleException(Exception ex) {

        ModelAndView modelAndView = new ModelAndView();

        modelAndView.addObject("errorMessage", ex.getMessage());

        modelAndView.setViewName("error");

        return modelAndView;

    }

}

@Controller

public class UserController {

    @GetMapping("/user/{id}")

    @ResponseBody

    @ResponseStatus(HttpStatus.OK)

    public UserDetails getUserDetails(@PathVariable("id") Long id) {

        // 查询用户信息

        UserDetails userDetails = userService.getUserDetails(id);

        if (userDetails == null) {

            throw new UserNotFoundException("User not found");

        }

        return userDetails;

    }

    @ExceptionHandler(UserNotFoundException.class)

    @ResponseStatus(HttpStatus.NOT_FOUND)

    @ResponseBody

    public String handleUserNotFoundException(UserNotFoundException ex) {

        return ex.getMessage();

    }

}

/**

 * 这个类使用 @ControllerAdvice 注解标注，表示这个类是一个全局控制器通知。在方法级别上，使用 @ModelAttribute 注解标注方法，表示这个方法会在所有控制器方法执行前执行，用于将当前登录用户信息添加到模型中。

 * 使用 @InitBinder 注解标注方法，表示这个方法会在所有控制器方法执行前执行，用于注册自定义的属性编辑器。

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

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

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

 */

@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 SimpleDateFormat("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;

    }

}

/**

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

 * 在这个例子中，使用 @CrossOrigin 注解指定允许来自 http://localhost:8080 域名的 GET 和 POST 请求访问该控制器中的方法。这意味着，在 http://localhost:8080 域名下的网页可以通过 XMLHttpRequest 对象发送 GET 和 POST 请求，访问该控制器中的方法。

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

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

 */

@RestController

@RequestMapping("/api")

@CrossOrigin(origins = "http://localhost:8080", methods = {RequestMethod.GET, RequestMethod.POST})

public class ApiController {

    @GetMapping("/users")

    public List<User> getUsers() {

        // 查询用户信息

        List<User> users = userService.getUsers();

        return users;

    }

}

/**

 * 这个类使用 @Service 注解标注，表示这个类是一个服务。在方法级别上，使用 @Async 注解标注方法，表示这个方法需要异步执行。

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

 * @Async 注解用于异步执行方法，可以提高应用程序的响应性能。它是一种简单但非常有效的解决方案，可以使得开发者更加轻松地编写并发应用程序。

 * @Async 注解是 Spring 框架中比较常用的注解之一，可以让开发者更加灵活地异步执行方法。需要注意的是，异步执行的方法必须在一个独立的线程中执行，因此需要使用线程池来管理异步线程的执行。

 */

@Service

public class UserService {

    @Async

    public CompletableFuture<UserDetails> getUserDetailsAsync(Long id) {

        // 查询用户信息

        UserDetails userDetails = userRepository.getUserDetails(id);

        return CompletableFuture.completedFuture(userDetails);

    }

}

/**

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

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

 * @Cacheable 注解用于缓存方法的返回结果，可以提高应用程序的执行效率。它是一种简单但非常有效的解决方案，可以使得开发者更加灵活地使用缓存来优化应用程序的性能。

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

 */

@Service

public class UserService {

    @Cacheable("userCache")

    public User getUser(Long id) {

        // 查询用户信息

        User user = userRepository.getUser(id);

        return user;

    }

}

/**

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

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

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

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

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

 */

@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 方法，表示这个方法的返回结果可以被缓存起来。同时，使用 @CachePut 注解标注 updateUser 方法，表示这个方法会更新或添加名为 "userCache" 的缓存。

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

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

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

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

 */

@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 注解标注，表示这个类是一个服务。同时，在类级别上使用 @Transactional 注解标注，表示这个类中的所有方法都需要使用事务进行操作。

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

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

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

 */

@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);

        }

    }

}

import org.springframework.transaction.annotation.Transactional;

import org.springframework.stereotype.Service;

@Service

public class MyService {

    @Transactional(propagation = Propagation.REQUIRED) // 仅将事务管理应用于该方法

    public void doSomething() {

        // 方法体

    }

    @Transactional(isolation = Isolation.READ_COMMITTED, timeout = 30) // 对该方法应用特定的事务属性

    public void doSomethingElse() {

        // 方法体

    }

}

@Transactional(rollbackFor = MyCustomException.class)

public void someMethod() throws MyCustomException {

    //  方法体

}

import org.springframework.context.annotation.Configuration;

import org.springframework.transaction.annotation.EnableTransactionManagement;

import org.springframework.transaction.jta.JtaTransactionManager;

import javax.annotation.Resource;

import javax.sql.DataSource;

import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;

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

import org.springframework.context.annotation.Bean;

import org.springframework.transaction.PlatformTransactionManager;

/**

 * @ConfigurationProperties：用于将属性文件中的值绑定到一个 Java 对象上，它可以将属性文件中的多个属性值注入到一个 Java 对象中，与 @Value 注解不同的是 @ConfigurationProperties 可以将属性文件中的值注入到多个属性中。

 */

@Configuration

@EnableTransactionManagement // 开启基于注解的事务管理

public class AppConfig {

    @Resource

    private DataSourceProperties dataSourceProperties;

    @Bean

    @ConfigurationProperties("spring.datasource")

    public DataSource dataSource() {

        return dataSourceProperties.initializeDataSourceBuilder().build();

    }

    @Bean

    public PlatformTransactionManager transactionManager(DataSource dataSource) {

        JtaTransactionManager transactionManager = new JtaTransactionManager();

        transactionManager.setTransactionManagerName("myTransactionManager");

        transactionManager.setUserTransactionName("myUserTransaction");

        return transactionManager;

    }

}

/**

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

 * 在这个例子中，我们定义了一个 MyAspect 类来实现某些功能的切面编程。为了让 Spring 框架能够自动为我们生成代理对象，我们需要将 MyAspect 类加入到 Spring 容器中，并且使用 @Bean 注解标注。另外，我们还定义了一个 UserService 类来实现某些业务功能。

 * @EnableAspectJAutoProxy 注解用于启用自动代理功能，可以使得开发者更加方便地使用 AOP 来实现某些功能。它是一种简单但非常有效的解决方案，可以让开发者更加轻松地使用切面编程来提高应用程序的性能和可维护性。

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

 */

@Configuration

@EnableAspectJAutoProxy

public class AppConfig {

    @Bean

    public MyAspect myAspect() {

        return new MyAspect();

    }

    @Bean

    public UserService userService() {

        return new UserService();

    }

}

/**

 * 这个类使用 @Aspect 注解标识，表示这个类是一个切面类。同时，我们还使用 @Component 注解标识这个类，以便 Spring 框架能够自动将它加入到 Spring 容器中。

 * 在这个例子中，我们定义了一个 MyAspect 类来实现某些功能的切面编程。在这个类中，我们定义了两个通知类型，即 @Before 和 @After，分别表示在目标方法执行前和执行后执行某些操作。这些通知类型的执行条件是通过切入点表达式来定义的。

 * @Aspect 注解用于标识一个类为切面类，可以使得开发者更加方便地使用 AOP 来实现某些功能。它是一种简单但非常有效的解决方案，可以让开发者更加轻松地使用切面编程来提高应用程序的性能和可维护性。

 * @Aspect 注解是 Spring 框架中比较常用的注解之一，用于标识一个类为切面类。需要注意的是，AOP 的使用需要谨慎操作，必要时需要考虑切入点、通知类型和切面顺序等来维护应用程序的性能和可维护性。

 */

@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.");

    }

}

/**

 * 这个类使用 @Aspect 注解标识，表示这个类是一个切面类。同时，我们还使用 @Component 注解标识这个类，以便 Spring 框架能够自动将它加入到 Spring 容器中。

 * 在这个例子中，我们定义了一个 MyAspect 类来实现某些功能的切面编程。在这个类中，我们使用 @Pointcut 注解定义了一个切入点，即 userServicePointcut () 方法。在这个切入点上，我们定义了两个通知类型，即 @Before 和 @After，分别表示在目标方法执行前和执行后执行某些操作。

 * @Pointcut 注解用于定义一个切入点，可以使得开发者更加方便地使用 AOP 来实现某些功能。它是一种简单但非常有效的解决方案，可以让开发者更加轻松地使用切面编程来提高应用程序的性能和可维护性。

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

 */

@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

public class MyAspect {

    @Before("execution(* com.example.UserService.*(..))")

    public void beforeAdvice() {

        System.out.println("Before advice is executed.");

    }

}

@Aspect

@Component

public class MyAspect {

    @After("execution(* com.example.UserService.*(..))")

    public void afterAdvice() {

        System.out.println("After advice is executed.");

    }

}

@Aspect

@Component

public class MyAspect {

    @Around("execution(* com.example.UserService.*(..))")

    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {

        System.out.println("Before advice is executed.");

        Object result = joinPoint.proceed();

        System.out.println("After advice is executed.");

        return result;

    }

}

@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);

    }

}

@Aspect

@Component

public class MyAspect {

    @AfterThrowing(pointcut = "execution(* com.example.UserService.*(..))", throwing = "ex")

    public void afterThrowingAdvice(Exception ex) {

        System.out.println("After throwing advice is executed. Exception is " + ex);

    }

}

@Aspect

@Component

@Order(1)

public class MyAspect1 {

    @Before("execution(* com.example.UserService.*(..))")

    public void beforeAdvice() {

        System.out.println("Before advice from MyAspect1 is executed.");

    }

}

@Aspect

@Component

@Order(2)

public class MyAspect2 {

    @Before("execution(* com.example.UserService.*(..))")

    public void beforeAdvice() {

        System.out.println("Before advice from MyAspect2 is executed.");

    }

}

/**

 * 在这个例子中，我们定义了一个 MyService 类，并使用 @Slf4j 注解来自动生成日志记录器。然后，在 doSomething () 方法中，我们直接使用 log 变量来记录日志，而不需要再引入其他的日志框架。

 * 需要注意的是，使用 @Slf4j 注解需要在编译器中安装 Lombok 插件，否则可能会出现编译错误。另外，虽然 @Slf4j 注解非常方便，但在实际应用中，我们还需要根据实际情况选择合适的日志框架，并编写相应的日志记录代码。

 * 总之，@Slf4j 是 Lombok 框架中的一个注解，可以在 Java 类中自动生成日志记录器，从而简化日志记录的过程。它是一种极为方便的解决方案，可以提高应用程序的可维护性和可读性。

 */

@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.");

    }

}

@Data

public class User {

    private Long id;

    private String name;

    private Integer age;

}

/**

 * 在这个例子中，我们定义了一个 User 类，并使用 @NoArgsConstructor 注解来自动生成一个无参构造方法。然后，在其他的 Java 类中，我们可以直接创建 User 对象的实例，而不需要手动编写无参构造方法。

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

 * 总之，@NoArgsConstructor 是 Lombok 框架中的一个注解，用于自动生成一个无参构造方法，从而简化 Java 开发的过程。它是一种极为方便的解决方案，可以提高应用程序的可维护性和可读性。

 */

@NoArgsConstructor

public class User {

    private Long id;

    private String name;

    private Integer age;

}

/**

 * 在这个例子中，我们定义了一个 User 类，并使用 @AllArgsConstructor 注解来自动生成一个全参构造方法。然后，在其他的 Java 类中，我们可以直接创建 User 对象的实例，并传入相应的参数，而不需要手动编写全参构造方法。

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

 * 总之，@AllArgsConstructor 是 Lombok 框架中的一个注解，用于自动生成一个全参构造方法，从而简化 Java 开发的过程。它是一种极为方便的解决方案，可以提高应用程序的可维护性和可读性。

 */

@AllArgsConstructor

public class User {

    private Long id;

    private String name;

    private Integer age;

}

/**

 * 在这个例子中，我们定义了一个 User 类，并使用 @Builder 注解来自动生成一个 Builder 模式的构造器。然后，在其他的 Java 类中，我们可以使用链式调用的方式设置 User 对象的属性，并最终创建一个不可变的对象。

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

 * 总之，@Builder 是 Lombok 框架中的一个注解，用于自动生成一个 Builder 模式的构造器，从而简化 Java 开发的过程。它是一种极为方便的解决方案，可以提高应用程序的可维护性和可读性。

 */

@Builder

public class User {

    private Long id;

    private String name;

    private Integer age;

}

@EqualsAndHashCode

public class User {

    private Long id;

    private String name;

    private Integer age;

}

@ToString(exclude = "password")

public class User {

    private Long id;

    private String name;

    private String password;

}

@Getter

public class User {

    private Long id;

    private String name;

    private Integer age;

}

@Setter

public class User {

    private Long id;

    private String name;

    private Integer age;

}