SpringBoot常用注解

SpringBoot常用注解

1.前言☕

大家好，我是Leo哥🫣🫣🫣，今天讲讲SpringBoot日常开发经常使用的注解。

2.@SpringBootApplication

这个注解是 Spring Boot 项目的基石，创建 SpringBoot 项目之后会默认在主类加上。

@SpringBootApplication
public class SpringSecurityJwtGuideApplication {
      public static void main(java.lang.String[] args) {
        SpringApplication.run(SpringSecurityJwtGuideApplication.class, args);
    }
}

我们可以把 @SpringBootApplication 看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合。

package org.springframework.boot.autoconfigure;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
   ......
}

package org.springframework.boot;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

作用：

SpringBoot的核心注解，主要目的是开启自动配置。它也是一个组合注解，主要组合了@Configuration，@EnableAutoConfiguration（核心）和@ComponentScan。可以通过@SpringBootApplication(exclude={想要关闭的自动配置的类名.class})来关闭特定的自动配置，其中@ComponentScan 让 spring Boot 扫描到 Configuration类并把它加入到程序上下文。

3.SpringBean相关

3.1 @Component,@Repository,@Service, @Controller

我们一般使用 @Autowired 注解让 Spring 容器帮我们自动装配 bean。要想把类标识成可用于 @Autowired 注解自动装配的 bean 的类,可以采用以下注解实现：

• @Component：通用的注解，可标注任意类为 Spring 组件。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。
• @Repository : 对应持久层即 Dao 层，主要用于数据库相关操作。
• @Service : 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。
• @Controller : 对应 SpringMVC 控制层，主要用于接受用户请求并调用 Service 层返回数据给前端页面。

3.2 @autowierd

自动将对象到类中，也就是将我们的对象交给Spring进行管理。比如我们在controller层注入service进行使用。

@RestController
@RequestMapping("/user")
@CrossOrigin
public class UserController {

    @Resource
    private UserService userService;

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        return Result.success(userService.selectById(id));
    }

3.3 @RestController

了解@RestController我们可以先来了解一下其他几个注解

@Controller

@Controller是Spring框架提供的注解，通过它标识的类，代表控制器类（控制层/表现层）。这里控制层里面的每个方法，都可以去调用@Service标识的类（业务逻辑层），而@Service标识的类中的方法可以继续调用@Resposity标识的接口实现类（Dao层/持久层）。

@Controller用于标记在一个类上，使用它标记的类就是一个SpringMVC 的Controller类，分发处理器会扫描使用该注解的类的方法，并检测该方法是否使用了@RequestMapping注解。@Controller只是定义了一个控制器类，而使用@RequestMapping注解的方法才是处理请求的处理器。@RequestMapping给出外界访问方法的路径，或者说触发路径，触发条件。

用@ResponseBody标记Controller类中的方法。把return的结果变成JSON对象返回。如果没有这个注解，这个方法只能返回要跳转的路径，即跳转的页面。有这个注解，可以不跳转页面，只返回JSON数据。

@RestController

@RestController是Spring4.0之后新增的注解。相当于 @Controller+@ResponseBody 合在一起的作用。

3.4 @Scope

声明 Spring Bean 的作用域，使用方法:

@Bean
@Scope("singleton")
public Person personSingleton() {
    return new Person();
}

四种常见的 SpringBean 的作用域：

• singleton: 唯一 bean 实例，Spring中的 bean 默认都是单例的。
• prototype: 每次请求都会创建一个新的 bean 实例。
• request: 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效。
• session: 每一个 HTTP Session 会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效。

3.5 @Configuration

一般是用来声明配置类的，可以用来替代 @component 注解。

@Configuration
public class BigEventApplication {
    @Bean
    public BeanService beanService() {
        return new BeanService();
    }
}

4.请求类型相关

下面介绍五中常见的请求类型。

GET ：获取特定资源。举个例子：GET /users（获取所有学生对象）

POST ：添加特定的资源。举个例子：POST /users（创建学生对象）

PUT ：更新资源。例如：PUT /users/1（更新编号为 1 的学生对象）

DELETE ：删除资源。例如：DELETE /users/1（删除编号为 1 的学生对象）

PATCH：更新资源，这里只用于大多数请求不太够的时候才会进行使用。

4.1 GET请求

@GetMapping("/{id}") 等价于@RequestMapping(value="/{id}",method=RequestMethod.GET)

@RestController
@RequestMapping("/user")
@CrossOrigin
public class UserController {

    @Resource
    private UserService userService;

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        return Result.success(userService.selectById(id));
    }

4.2 POST请求

  /**
     * 注册用户
     * @param username 用户名
     * @param password 密码
     * @return 返回结果
     */
    @PostMapping("/register")
    public Result register(String username,String password) {
        return userService.register(username,password);
    }

4.3 PUT请求

 /**
     * 更新用户基本信息
     * @param user 用户信息
     * @return 返回结果
     */
    @PutMapping("/update")
    public Result update(@RequestBody User user) {
        return userService.updateInfo(user);
    }

4.4 DELETE请求

   /**
     * 删除文章分类
     * @param id 分类id
     * @return 返回结果
     */
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        return categoryService.delete(id);
    }

4.5 PATCH请求

   /**
     * 更新用户头像
     * @param avatarUrl
     * @return
     */
    @PatchMapping("/updateAvatar")
    public Result updateAvatar(@RequestParam String avatarUrl){
        System.out.println("url = " + avatarUrl);
        return userService.updateAvatar(avatarUrl);
    }

5.读取配置信息相关

有时候我们需要读取一些自定义的配置信息，比如阿里云OSS的配置文件信息，微信以及小程序认证信息等，都需要进行读取。

5.1 @Value(常用)

使用 @Value("${property}") 读取比较简单的配置信息：

@Value("${name}")
String name;

5.2 @ConfigurationProperties

通过@ConfigurationProperties读取配置信息并与 bean 绑定。

@Component
@ConfigurationProperties(prefix = "profile")
class LibraryProperties {
    @NotEmpty
    private String hobby;
    private List<Book> books;

    @Setter
    @Getter
    @ToString
    static class Book {
        String name;
        String description;
    }
  省略getter/setter
  ......
}

你可以像使用普通的 SpringBean 一样，将其注入到类中使用。

5.3 @PropertySource

是一个更高级的读取方式，它允许你指定配置文件的路径。如果你想要从特定的配置文件（如application.properties 或application.yml ）中获取配置，可以使用@PropertySource注解

5.4 @Environment

虽然不是直接用于配置文件的读取，但@Environment注解也能够用于配置环境变量，比如app.env 等。在某些情况下，可能会需要这种方式来间接地控制环境变量。

我们需要在启动类中读取一些application.yml的配置文件就可以这么做。

@SpringBootApplication
public class BigEventApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(BigEventApplication.class, args);
        Environment environment = context.getBean(Environment.class);

        System.out.println("访问链接：http://localhost:" + environment.getProperty("server.port"));
        System.out.println("(♥◠‿◠)ﾉﾞ  项目启动成功 ლ(´ڡ`ლ)ﾞ \n");
    }
}

5.5 @ImportResource

这是Spring 2.5之后引入的，用于加载外部配置文件到Spring的上下文中。它可以放在配置类、方法或配置类上，通过指定的位置来加载配置文件。

@ImportResource 注解用于导入Spring的配置文件，让配置文件里面的内容生效；(就是以前写的springmvc.xml、applicationContext.xml) Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别； 想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上。 注意！这个注解是放在主入口函数的类上或配置类上

@ImportResource(locations = "classpath:beans.xml")

6.前后端传值相关

学习有关前后端传值相关注解，助你更快开始CRUD。

6.1 @PathVariable

@PathVariable用来进行路径传参。

@GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        return Result.success(userService.selectById(id));
    }

6.2 @RequestParam

@RequestParam用于获取查询参数。

    /**
     * 获取文章列表
     * @return 返回结果
     */
    @GetMapping
    public Result<PageBean<Article>> pageList(Integer pageNum, Integer pageSize,
                                              @RequestParam(required = false) Integer categoryId,
                                              @RequestParam(required = false) String state) {

        return articleService.selectPageList(pageNum, pageSize, categoryId, state);
    }

当我们发送：https://localhost:8089/articles?pageNum=1,pageSize=10,categoryId=5

此时我们后端服务器收到的为：pageNum=1,pageSize=10,categoryId=5

注意： 如果命名和函数参数命名一致，@RequestParam还可以省略

6.3 @RequestBody

该注解和 @RequestParam 殊途同归，我们使用该注解将所有参数转换，在代码部分在一个个取出来。比如 @RequestBody User user 表示利用 User 类接受前端传过来的参数。

还有 @RequestHeader 来获取头信息里的值，@CookieValue来获取 Cookie 值等等

⭐ 现在大多数互联网项目都是采用 前后端分离 的方式开发，前端 人员负责页面展示和数据获取，后端 负责业务逻辑处理和接口封装。前后端之间的交互通常使用 JSON 数据，一般来说后端使用 @RequestBody 注解来获取前端传过来的 JSON 数据。

代码示例：

  @PutMapping
    public Result update(@RequestBody Article article) {
        return articleService.update(article);
    }

6.4 @RequestMapping

@RequestMapping注解是一个用来处理请求地址映射的注解，可用于映射一个请求或一个方法，可以用在类或方法上。

• 标注在方法上

用于方法上，表示在类的父路径下追加方法上注解中的地址将会访问到该方法

@Controller
public class HelloController {

    @RequestMapping("/requestTest")
    public String requestTest(){
        return "success";
    }
}

• 标注在类和方法上

用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

注意：当你在类上添加RequestMapping注解后，如果要请求映射，就意味着请求要先映射到标注类的位置，然后再映射到该类的方法上

@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/requestTest")
    public String requestTest(){
        return "success";
    }
}

• 参数列表

参数	说明
value	@RequestMapping 的 value 属性必须设值； @RequestMapping 的 value 属性是通过当前请求的请求地址来匹配请求； 从源码中可以看到value属性是一个字符串类型的数组，因此说明可以将多个请求映射到一个方法上，只需要给 value 来指定一个包含多个路径的数组。
method	@RequestMapping的method属性是通过当前请求的请求方式来匹配请求； 浏览器向服务器发送请求，请求方式有很多GET、HEAD、POST、PUT、PATCH、DELETE、OPTIONS、TRACE。可以使用 method 属性来约束请求方式。
headers	@RequestMapping的headers属性是通过当前请求的请求头信息来匹配请求； @RequestMapping的headers属性是一个字符串类型的数组，可以通过下面四种表达是来设置匹配关系 例如： "header"：要求请求映射的请求必须为包含 header的请求头信息 "!header"：要求请求映射的请求必须为不包含 header的请求头信息 "header=value"：要求请求映射的请求必须为包含 header的请求头信息，并且header的值必须为value "header!=value"：要求请求映射的请求必须为包含 header的请求头信息，并且header的值必须不是value
params	@RequestMapping的params属性是通过当前请求的请求参数来匹配请求； @RequestMapping的params属性是一个字符串类型的数组，可以通过下面四种表达是来设置匹配关系 例如： "param"：要求请求映射的请求必须为包含 param的请求参数 "!param"：要求请求映射的请求是不能包含param的请求参数 "param=value"：要求请求映射的请求必须包含 param 的请求参数，且 param 参数的值必须为 value "param!=value"： 要求请求映射的请求是必须包含 param 的请求参数，其值不能为 value。

7.参数校验相关

JSR(Java Specification Requests） 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，这样就可以在需要校验的时候进行校验了，非常方便！

校验的时候我们实际用的是 Hibernate Validator 框架。Hibernate Validator 是 Hibernate 团队最初的数据校验框架，Hibernate Validator 4.x 是 Bean Validation 1.0（JSR 303）的参考实现，Hibernate Validator 5.x 是 Bean Validation 1.1（JSR 349）的参考实现，目前最新版的 Hibernate Validator 6.x 是 Bean Validation 2.0（JSR 380）的参考实现。

SpringBoot 项目的 spring-boot-starter-web 依赖中已经有 hibernate-validator 包，不需要引用相关依赖。

7.1 常见的校验字段

@NotEmpty 被注释的字符串的不能为 null 也不能为空

@NotBlank 被注释的字符串非 null，并且必须包含一个非空白字符

@Null 被注释的元素必须为 null

@NotNull 被注释的元素必须不为 null

@AssertTrue 被注释的元素必须为 true

@AssertFalse 被注释的元素必须为 false

@Pattern(regex=,flag=)被注释的元素必须符合指定的正则表达式

@Email 被注释的元素必须是 Email 格式。

@Min(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值

@Max(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值

@DecimalMin(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值

@DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值

@Size(max=, min=)被注释的元素的大小必须在指定的范围内

7.2 controller验证

  /**
     * 添加文章
     * @param article
     * @return 返回结果
     */
    @PostMapping
    public Result insert(@RequestBody @Validated Article article) {
        return articleService.insertArticle(article);
    }

我们在需要验证的参数上加上了@Valid注解，如果验证失败，它将抛出MethodArgumentNotValidException。

7.3 实体类验证

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
    * ID
    */
    private Integer id;

    /**
    * 用户名
    */
    @NotEmpty
    @Pattern(regexp = "^[a-zA-Z0-9]{4,16}$")
    private String username;

    /**
    * 密码
    */
    @NotEmpty
    @Pattern(regexp = "^[a-zA-Z0-9]{4,16}$")
    private String password;

    /**
    * 昵称
    */
    @NotEmpty
    private String nickname;

    /**
    * 邮箱
    */
    @Email
    private String email;

    /**
    * 头像
    */
    private String userPic;

    /**
    * 创建时间
    */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;

    /**
    * 更新时间
    */
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime;

    private static final long serialVersionUID = 1L;
}

8.事务相关

Spring中的事务相关注解主要包括@Transactional和其变体。@Transactional注解支持声明式事务管理，这意味着它不需要通过XML配置来配置事务，而是通过注解的方式来实现事务的开启、提交或回滚。

这种方式的优点是简单易用，可以与Spring数据访问抽象完美集成。

@Transactional注解的使用方法简单明了，只需在方法上添加此注解即可。例如，在保存用户的方法中添加注解后，使用默认配置并抛出异常，事务就会被开启和执行。此外，@Transactional也可以用作到类上或者接口，以覆盖所有方法或接口的实现

Spring提供了两种事务管理方式，即编程式事务管理（如TransactionTemplate）和声明式事务管理（如@Transactional注解）。

编程式事务是通过编码方式实现事务的，而声明式事务基于AOP，将具体业务逻辑与事务逻辑解耦。

@Transactional注解通过动态代理实现了对Bean的管理和切片，从而使得每个类都生成一个代理对象，这些代理对象负责管理事务

在使用@Transactional注解时，还可以通过transactionManager属性指定事务管理器的标识，这可以是一个bean名称，也可以是一个字符串。这样，即使在一个应用程序中可能需要使用多个独立的事务管理器，也能通过@Transactional注解来实现。

总的来说，@Transactional注解是Spring中传明式事务管理的关键注解，它提供了一种简单、易用且易于理解的事务管理机制，有助于提高代码的清晰性和可维护性

@Transactional(rollbackFor = Exception.class)
public void test() {
  //业务操作
}

9.JSON相关

在Spring框架中，JSON相关的注解主要用于处理JSON数据的序列化和反序列化。Spring Boot提供了与Jackson 、Gson 和 JSONB 三种JSON映射库的集成。Jackson是Spring Boot默认集成的JSON解析器，它支持将Java对象和Java对象转换为JSON字符串或JSON字符串到Java对象的转换。此外，还有一些特定的注解用于特定场景下的JSON数据处理

9.1 @JsonAnyGetter

该注解用于将扩展的map标的值映射到实体类上的实体类。

  class  UserJsonAnyGetter  {
    private String userName;
    private Map<String, String> properties;
    @JsonAnyGetter
    public Map<String, String> getProperties() {
        return properties;
    }

9.2 @JsonGetter

此注解在getter方法中可替代@JsonProperty注释，替换json的key值。

  class  UserJsonGetter  {
    private String userName;
    private Integer id;
    @JsonGetter("name")
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }

9.3 @JsonIgnoreProperties

@JsonIgnoreProperties 作用在类上用于过滤掉特定字段不返回或者不解析。

//生成json时将userRoles属性过滤
@JsonIgnoreProperties({"userRoles"})
public class User {

    private String name;
    private String address;
    private String password;
    private List<UserRole> userRoles = new ArrayList<>();
}

9.4 @JsonFormat

@JsonFormat控制序列化和反序列化的日期格式。

public class EventWithFormat {
    public String name;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd hh:mm:ss")
    public Date eventDate;

    public EventWithFormat() {
        super();
    }

    public EventWithFormat(final String name, final Date eventDate) {
        this.name = name;
        this.eventDate = eventDate;
    }

    public Date getEventDate() {
        return eventDate;
    }

    public String getName() {
        return name;
    }
}

9.5 @JsonIgnore

@JsonIgnore 一般用于属性上面

public class User {

    private String userName;
    private String fullName;
    private String password;
    
    //生成json时将userRoles属性过滤
    @JsonIgnore
    private List<UserRole> userRoles = new ArrayList<>();
}

10.测试相关

Spring中测试相关的注解主要包括但不限于以下几种：

10.1 @Test

这是一个核心注解，用于声明一个测试类，通常用于测试类或方法的验证。它是 SpringBoot Test 中支持的一个注解，与JUnit等测试框架结合使用，提供了便捷高效的测试手段。

 @Test
    public void testAddUser() {
        User user = new User();
        user.setName("john");
        user.setAddress("earth");
        userService.add(user);
    }

10.2 @SpringBootTest

注解用于指定SpringBoot应用程序的入口类，默认会根据包名逐级往上找，一直找到一个SpringBoot主程序class为止，然后启动该类为测试提供上下文

@SpringBootTest(classes = {BigEventApplication.class})
public class RedisTest {
    @Autowired
    private RedisCache redisCache;

    /**
     * 用于测试: redis
     */
    @Test
    public void testRedis() {
        redisCache.setKey("age","20", 10, TimeUnit.SECONDS);
        String name =  redisCache.getKey("name");
        System.out.println("name = " + name);
        redisCache.deleteObject("年龄");
    }
}

10.3 @RunWith

这是一个高级注解，允许测试类在没有特定配置的情况下进行测试。这种方式不需要XML配置，使得配置和测试变得更加一体化。

@SpringBootTest(classes = SpringBootMemberTest.Config.class)
@TestPropertySource(locations = "classpath:test-application.properties")
@RunWith(SpringRunner.class)
public class SpringBootMemberTest {

    @Autowired
    private Environment env;
    @MockBean
    private UserDAO userDAO;
    @Autowired
    private MemberService memberService;

    @Before
    public void init() {
        Mockito.when(userDAO.insertMember(Mockito.any())).thenReturn(System.currentTimeMillis());
    }

    @Test
    public void insert_member() {
        System.out.println(memberService.insertMember("windowsxp", "abc123"));
        Assert.assertNotNull(memberService.insertMember("windowsxp", "abc123"));
    }

    @Configuration
    static class Config {

        @Bean
        public MemberService memberService() {
            return new MemberServiceImpl();
        }
    }

}

如上述代码所示，基于Spring -Boot-Test的单测需要使用注解@SpringBootTest 标注，声明该类为一个SpringBoot 测试类，同时与Spring-Test 类似，通过classes属性声明当前测试类使用的配置，本示例中是SpringBootMemberTest.Config。

对于需要Mock的类型，可以使用@MockBean注解来修饰，它会生成对应类型的Mock对象，并将其注入到容器中。当然SpringBoot离不开application配置，可以通过@TestPropertySource注解指定当前测试用例所使用的application配置。

如果测试的类需要依赖一些starter才能工作，那就需要在测试类上增加@EnableAutoConfiguration，同时在application配置中增加一些属性，这样该测试就会像一个SpringApplication一样被启动起来。

11.AOP相关

在Spring框架中，AOP通过注解方式来实现，这使得AOP的配置更加直观和易于使用。以下是一些关键的注解及其用途：

11.1 @Aspect（切面）

用于定义切面。切面包含了通知（Advice）和切点（Pointcut），是AOP的主角之一。

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        // 前置通知的逻辑
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        // 后置通知的逻辑
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

11.2 @Before（前置通知）

声明此方法为前置通知，即目标方法执行之前就会先执行被此注解标注的方法。

@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
    // 前置通知的逻辑
    System.out.println("Before method: " + joinPoint.getSignature().getName());
}

11.3 @AfterReturning（返回通知）

返回通知在连接点正常执行并返回结果后执行，用于处理返回结果。

@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
    // 返回通知的逻辑
    System.out.println("After returning from method: " + joinPoint.getSignature().getName());
    System.out.println("Result: " + result);
}

11.4 @Pointcut（Pointcut）

一个用来匹配连接点（JoinPoint）的断言或表达式。它指定了在何时执行增强方法。

11.5 @AfterThrowing（异常通知）

异常通知在连接点抛出异常时执行，用于处理异常情况。

@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
public void logAfterThrowing(JoinPoint joinPoint, Throwable exception) {
    // 异常通知的逻辑
    System.out.println("After throwing exception from method: " + joinPoint.getSignature().getName());
    System.out.println("Exception: " + exception.getMessage());
}

11.5 Around（环绕）

使用注解来装配AOP装配，需要先定义注解，然后使用@Around("@annotation(name)")实现装配。

@Around("execution(public * update*(..))")
public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
    // 对update开头的方法切换数据源:
    String old = setCurrentDataSource("master");
    Object retVal = pjp.proceed();
    restoreCurrentDataSource(old);
    return retVal;
}

11.6 EnableAspectJAutoProxy（启用AspectJAutoProxy）

在配置文件中启用自动代理功能，以便Spring能够自动识别并代理目标类上的增强方法。

12.其他相关注解

12.1 @Async

多线程异步方法。 注解在方法上标示这是一个异步方法，在类上标示这个类所有的方法都是异步方法。

12.2 @EnableScheduling

开启计划任务。 注解在配置类上，开启对计划任务的支持。

12.3 @Scheduled

计划任务。 注解在方法上，声明该方法是计划任务。支持多种类型的计划任务：cron,fixDelay,fixRate。

12.4 @Cacheable

缓存。 声明数据缓存。

13.总结🍭

以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是Leo，一个在互联网行业的小白，立志成为更好的自己。

如果你想了解更多关于Leo，可以关注公众号-程序员Leo，后面文章会首先同步至公众号。