Spring Boot注解大全：从入门到精通，轻松掌握Spring Boot核心注解！

目录

1、前言

2、介绍

2.1 Spring Boot简介

2.2 为什么要学习Spring Boot注解

3、Spring Boot基本注解

3.1 @SpringBootApplication

3.2 @EnableAutoConfiguration

3.3 @ComponentScan

4、控制器注解

4.1 @RestController

4.2 @RequestMapping

4.3 @PathVariable

4.4 @RequestParam

4.5 @RequestBody

4.6 @ResponseBody

5、数据库注解

5.1 @Entity

5.2 @Table

5.3 @Column

5.4 @Id

5.5 @GeneratedValue

5.6 @Repository

6、事务注解

6.1 @Transactional

6.2 @Propagation

6.3 @Isolation

6.4 @ReadOnly

7、缓存注解

7.1 @Cacheable

7.2 @CachePut

7.3 @CacheEvict

8、定时任务注解

8.1 @Scheduled

8.2 @EnableScheduling

9、异步方法注解

9.1 @Async

10、条件注解

10.1 @Conditional

11、配置注解

11.1 @Configuration

11.2 @Value

11.3 @ConfigurationProperties

12、AOP注解

13、测试注解

13.1 @RunWith

13.2 @SpringBootTest

13.3 @MockBean

14、安全注解

14.1 @EnableWebSecurity

14.2 @Secured

14.3 @PreAuthorize

15、结语

1、前言

????????Spring Boot是一个快速开发框架，它简化了Spring应用程序的开发过程。一个标准的Spring Boot应用程序使用注解来配置和管理各个组件，这些注解可以帮助开发者快速地理解和配置应用程序的行为。

????????本篇文章将介绍Spring Boot中的常用注解，帮助读者全面了解Spring Boot的使用。我们将从入门开始，一步步地介绍每个注解的用途和使用方法，帮助读者快速掌握Spring Boot的核心注解。

????????在学习本篇文章之前，读者需要对Spring框架有一定的了解，并且具备Java编程的基础知识。通过学习本篇文章，读者将学会如何使用Spring Boot注解来配置和管理应用程序的各个组件，从而提高开发效率。

????????本篇文章分为若干章节，每个章节将介绍一个或多个注解。每个章节都包含了注解的说明、用法示例和注意事项。通过逐步学习，读者将逐渐掌握Spring Boot核心注解的使用技巧。

????????希望本篇文章能够帮助读者深入理解和熟练运用Spring Boot注解，从而在实际开发中提高效率和质量。在学习过程中，如有任何问题和疑惑，欢迎随时留言讨论。让我们一起开始探索Spring Boot注解的奥秘吧！

2、介绍

2.1 Spring Boot简介

????????Spring Boot是一个开源的Java框架，它被设计用来简化Spring应用的创建和开发过程。它基于Spring框架，通过自动配置和约定大于配置的方式，提供了一种快速创建独立的、可部署的Spring应用的方法。

????????Spring Boot提供了一种快速开发应用的方式，它简化了很多常见的配置，包括数据库连接、日志配置等。同时，Spring Boot还内置了一些常用的功能，如健康监测、性能监控等，这些功能可以通过简单的配置就能够使用。

????????Spring Boot还支持嵌入式的Web服务器，可以方便地创建RESTful服务或者Web应用。

????????总之，Spring Boot通过提供一种简化和快速开发的方式，减少了开发者在配置和部署上的工作量，使开发过程更加高效和愉快。

2.2 为什么要学习Spring Boot注解

学习Spring Boot注解有以下几个原因：

1. 简化开发：Spring Boot注解提供了一种简单而快速的方式来开发应用程序。使用注解可以减少编写大量的配置代码，并提供了一套规范和约束，使得开发变得更加高效和易于维护。

2. 提高代码可读性：注解提供了一种声明式的方式来描述代码的行为和功能，使得代码更易于理解和阅读。通过注解，可以清晰地表达代码的含义和作用，提高代码的可读性。

3. 提供更强大的功能：Spring Boot注解提供了丰富的功能和扩展点，可以帮助我们实现各种需求。例如，通过注解可以实现依赖注入、AOP、事务管理等功能，简化开发过程。

4. 与Spring生态系统紧密集成：Spring Boot注解与Spring框架的其他组件紧密集成，可以方便地使用Spring的各种功能。通过注解，可以轻松地集成数据库、消息队列、缓存、安全等组件，提供更完善的应用开发能力。

5. 与Spring Boot自动配置配合使用：Spring Boot注解可以与Spring Boot的自动配置机制配合使用，帮助我们快速构建一个可用的应用程序。通过注解，可以轻松地配置和管理应用程序的各种组件，减少开发人员的工作量。

总而言之，学习Spring Boot注解可以提高开发效率，提高代码可读性，并且与Spring框架和Spring Boot的自动配置机制紧密集成，帮助我们构建高效、可靠的应用程序。

3、Spring Boot基本注解

3.1 @SpringBootApplication

@SpringBootApplication是一个组合注解，它是由以下三个注解组成的：

1. @SpringBootConfiguration：标注当前类是一个Spring Boot的配置类，一般用于定义配置信息，如Bean的定义、数据源的配置等。

2. @EnableAutoConfiguration：开启Spring Boot的自动配置，通过这个注解，Spring Boot会根据依赖的jar包和配置文件的设置，自动配置Spring容器。

3. @ComponentScan：扫描当前包以及子包下的所有类，将标注了@Component等相关注解的类自动注册为Spring容器中的Bean。

@SpringBootApplication注解的使用一般放在Spring Boot的启动类上，它起到了替代传统的@Configuration、@EnableAutoConfiguration和@ComponentScan等注解的作用。

以下是一个简单的示例：

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

在上面的示例中，@SpringBootApplication注解被应用在Application类上，它告诉Spring Boot这是一个Spring Boot应用的入口类，可以启动Spring容器。

总结来说，@SpringBootApplication是一个非常方便的注解，它简化了Spring Boot应用的配置，减少了开发人员的工作量，提高了开发效率。

3.2 @EnableAutoConfiguration

@EnableAutoConfiguration是Spring Boot的核心注解之一，它的作用是开启自动配置。

在使用Spring Boot时，我们可以引入各种不同的依赖，比如数据库、消息队列、Web框架等等。而@EnableAutoConfiguration注解的作用就是根据引入的依赖自动配置相应的组件。

@EnableAutoConfiguration注解使用的位置有两种情况：

1. 在Spring Boot主类上使用：在Spring Boot的主类上添加@EnableAutoConfiguration注解，表示开启自动配置。Spring Boot会根据引入的依赖自动配置相应的组件。

@SpringBootApplication
@EnableAutoConfiguration
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

? ? ? ? 2. 在其他配置类上使用：在其他配置类上添加@EnableAutoConfiguration注解，表示开启自动配置。这种情况一般用于引入某个特定的组件自动配置。

@EnableAutoConfiguration注解实际上是一个组合注解，它包含了多个Spring Boot的自动配置注解。它会根据classpath下的jar包，通过一定的规则自动配置Spring应用程序的上下文。

@EnableAutoConfiguration注解的原理是通过SpringFactoriesLoader机制，从classpath下的META-INF/spring.factories文件中加载并实例化AutoConfiguration类。

在实际使用中，我们可以通过exclude属性来排除某个自动配置类，使用excludeName属性来排除某个自动配置类的全限定名。

@SpringBootApplication
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

总结一下，@EnableAutoConfiguration注解的作用是开启Spring Boot的自动配置功能。通过该注解，Spring Boot会根据引入的依赖自动配置相应的组件，大大简化了项目的配置工作。

3.3 @ComponentScan

@ComponentScan注解是Spring框架中的一个注解，用于自动扫描和装配被@Component、@Service、@Controller和@Repository等注解标识的类。

@ComponentScan注解可以加在配置类上，表示启用自动扫描的功能。它会自动扫描指定包及其子包下的类，并将被注解标识的类注册为Spring容器中的bean。

@ComponentScan注解可以指定多个要扫描的包，可以使用basePackages属性或value属性来指定。示例代码如下：

@Configuration
@ComponentScan(basePackages = {"com.example.package1", "com.example.package2"})
public class AppConfig {

}

在上述示例中，我们指定了要扫描的两个包com.example.package1和com.example.package2。

@ComponentScan注解还有其他的属性，包括：

1. basePackageClasses：可以通过指定一组类来扫描它们所在的包，而不需要显式地指定包名。
2. includeFilters：可以通过指定过滤器来限定扫描的类，只有符合过滤规则的类才会被注册为bean。
3. excludeFilters：可以通过指定排除过滤器来排除某些类，这些类不会被注册为bean。

使用@ComponentScan注解可以简化配置，不再需要一个个手动配置类，Spring会自动扫描并注册所有符合条件的类。

需要注意的是，@ComponentScan注解默认会扫描当前配置类所在的包及其子包下的类。如果希望扫描其他包的类，需要使用basePackages或value属性指定。另外，如果要使用@ComponentScan注解，需要在配置类上加上@Configuration注解。

4、控制器注解

4.1 @RestController

@RestController注解是Spring MVC中的一个注解，用于标识一个类是一个RESTful风格的控制器。 @RestController注解将类标记为一个控制器，并将返回的结果作为HTTP响应直接发送给客户端，而不是渲染到视图。

@RestController注解相当于@Controller和@ResponseBody的结合体。它将@Controller注解和@ResponseBody注解合并到一个注解中，简化了代码的编写。

使用@RestController注解时，可以在类级别上使用@RequestMapping注解来定义请求映射的根路径，也可以在方法级别上使用@RequestMapping注解来定义具体的请求映射。

以下是@RestController注解的使用示例：

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

在上面的示例中，标有@RestController注解的类UserController被定义为一个控制器。使用@RequestMapping注解定义了根路径为"/users"，因此所有的请求都是以"/users"开头的。

@RestController注解可以用于处理GET、POST、PUT、DELETE等HTTP请求。在示例中，使用@GetMapping、@PostMapping、@PutMapping、@DeleteMapping注解分别指定了处理GET、POST、PUT、DELETE请求的方法，并通过@PathVariable和@RequestBody注解获取URL路径参数和请求体参数。

总而言之，@RestController注解是Spring MVC中用于构建RESTful风格控制器的注解，它简化了代码的编写，并将方法的返回结果直接作为HTTP响应发送给客户端。

4.2 @RequestMapping

@RequestMapping注解是Spring MVC中常用的注解之一，用于映射URL和方法的关系。它可以用于类级别和方法级别。

在类级别上，@RequestMapping注解可以指定一个基础URL，然后在方法级别上再指定具体的URL。例如：

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/list")
    public String listUsers() {
        // ...
    }

    @RequestMapping("/add")
    public String addUser() {
        // ...
    }
}

上面的例子中，UserController类被映射到了"/user"路径下，而listUsers()方法和addUser()方法分别被映射到了"/user/list"和"/user/add"路径下。

在方法级别上，@RequestMapping注解可以指定HTTP请求的方法。例如：

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping(value = "/list", method = RequestMethod.GET)
    public String listUsers() {
        // ...
    }

    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public String addUser() {
        // ...
    }
}

上面的例子中，listUsers()方法只接受GET请求，而addUser()方法只接受POST请求。

除了基本的URL和HTTP方法的指定，@RequestMapping注解还支持其他属性的配置，包括请求参数、请求头、响应头、请求体等。例如：

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping(value = "/list", params = "status=active")
    public String listActiveUsers() {
        // ...
    }

    @RequestMapping(value = "/list", headers = "X-Custom-Header=123")
    public String listUsersWithCustomHeader() {
        // ...
    }

    @RequestMapping(value = "/add", consumes = "application/json")
    public String addUserFromJson(@RequestBody User user) {
        // ...
    }
}

上面的例子中，listActiveUsers()方法只处理带有"status=active"参数的请求，listUsersWithCustomHeader()方法只处理带有自定义头部"X-Custom-Header=123"的请求，addUserFromJson()方法只处理Content-Type为"application/json"的请求，并将请求体解析为User对象。

总结起来，@RequestMapping注解是Spring MVC中用于映射URL和方法的关系的重要注解，它可以用于类级别和方法级别，支持各种属性的配置，使得开发者能够灵活地处理各种请求和响应。

4.3 @PathVariable

@PathVariable注解是Spring MVC框架中的一个注解，用于将URL中的占位符参数绑定到方法的参数上。

使用@PathVariable注解的方式有两种：

1. 在方法的参数中直接使用@PathVariable注解

在方法参数中使用@PathVariable注解时，需要将注解的值与URL中的占位符参数名称保持一致。例如，URL为"/users/{id}"，则方法参数中的注解为@PathVariable("id")。

@GetMapping("/users/{id}")
public User getUserById(@PathVariable("id") Long id) {
    // 根据id查询用户信息
    User user = userService.getUserById(id);
    return user;
}

? ? ? ? 2. 在方法的参数上使用@PathVariable注解和@RequestParam注解

有时候，URL中的占位符参数与请求参数有重复的情况，此时可以在方法参数上同时使用@PathVariable注解和@RequestParam注解来分别绑定URL中的占位符参数和请求参数。

@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id, @RequestParam String name) {
    // 根据id和name查询用户信息
    User user = userService.getUserByIdAndName(id, name);
    return user;
}

需要注意的是，@PathVariable注解默认是必须要匹配URL中的占位符参数的，如果URL中的占位符参数不存在，则会抛出异常。如果想要设置成可选的，可以使用required属性来设置。

@GetMapping("/users/{id}")
public User getUserById(@PathVariable(value = "id", required = false) Long id) {
    if (id == null) {
        return null;
    }
    // 根据id查询用户信息
    User user = userService.getUserById(id);
    return user;
}

@PathVariable注解还有其他一些属性，例如value和name属性用于指定占位符参数的名称，defaultValue属性用于指定参数的默认值，等等。

总结一下，@PathVariable注解是Spring MVC框架中用于将URL中的占位符参数绑定到方法参数上的注解，可以通过方法参数中使用@PathVariable注解或者同时使用@PathVariable注解和@RequestParam注解来使用。

4.4 @RequestParam

@RequestMapping是Spring MVC框架中的一个注解，用于将HTTP请求映射到控制器方法上。在控制器方法的参数列表中，可以使用@RequestParam注解来获取请求参数的值。

@RequestParam注解可以用于将请求参数绑定到控制器方法的参数上，用法如下：

1. 使用@RequestParam注解直接绑定参数值：

@RequestMapping("/example")
public String example(@RequestParam String param) {
    // 处理param参数
    return "example";
}

? ? ? ? 2. 设置请求参数的默认值：

@RequestMapping("/example")
public String example(@RequestParam(defaultValue = "default") String param) {
    // 处理param参数
    return "example";
}

? ? ? ? 3. 设置请求参数为必需项：

@RequestMapping("/example")
public String example(@RequestParam(required = true) String param) {
    // 处理param参数
    return "example";
}

? ? ? ? 4. 绑定多个请求参数：

@RequestMapping("/example")
public String example(@RequestParam String param1, @RequestParam String param2) {
    // 处理param1和param2参数
    return "example";
}

? ? ? ? 5. 使用@RequestParam注解来获取URL路径中的参数：

@RequestMapping("/example/{param}")
public String example(@PathVariable("param") String param) {
    // 处理param参数
    return "example";
}

这些是@RequestParam注解的一些常用使用方法，通过使用@RequestParam注解，可以方便地获取和处理HTTP请求的参数。

4.5 @RequestBody

@RequestBody注解用于将HTTP请求的请求体转换为方法的参数。它可以用于处理多种类型的请求，如POST、PUT、DELETE等。

使用@RequestBody注解时，需要注意以下几点：

1. @RequestBody注解只能用于方法的参数上，不能用于方法的返回值上。

2. @RequestBody注解可以与@RestController或@Controller注解一起使用，以标识方法是一个处理请求的方法。

3. @RequestBody注解可以用于处理请求体的各种媒体类型，如JSON、XML等。

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

@RestController
public class UserController {

    @PostMapping("/users")
    public ResponseEntity<User> createUser(@RequestBody User user) {
        // 处理user对象
        // ...
        return ResponseEntity.ok(user);
    }
}

在上面的示例中，createUser方法使用@RequestBody注解将HTTP请求的请求体转换为User对象。方法的返回值是ResponseEntity<User>，表示返回一个包含User对象的HTTP响应。

当接收到一个POST请求"users"时，如果请求体是一个JSON对象，例如：

{
    "name": "Alice",
    "age": 20
}

那么createUser方法将会接收到一个User对象，其属性name为"Alice"，age为20。然后可以对该对象进行处理，并将其包装在ResponseEntity中返回给客户端。

需要注意的是，@RequestBody注解是通过使用合适的HttpMessageConverter来解析请求体的。默认情况下，Spring Boot提供了许多内置的HttpMessageConverter实现，可以处理各种媒体类型的请求体。如果需要处理其他类型的请求体，可以自定义HttpMessageConverter。

另外，@RequestBody注解还支持使用@Valid注解进行请求体的验证，以确保请求体的内容符合预期。例如，可以在User类的属性上添加注解来验证其值的有效性。如果验证失败，将会返回一个包含错误信息的HTTP响应。

总结来说，@RequestBody注解是Spring MVC框架中用于将HTTP请求体转换为方法参数的注解。可以用于处理各种类型的请求，如POST、PUT、DELETE等。使用@RequestBody注解时，需要注意请求体的格式和方法参数的类型，以及可能需要进行请求体验证的情况。

4.6 @ResponseBody

@ResponseBody是Spring MVC的注解之一，用于指示Controller方法的返回值直接写入HTTP响应体中。

使用@ResponseBody注解的方法可以发送任何类型的响应内容，包括将Java对象序列化为JSON、XML或其他格式的数据。

使用@ResponseBody注解有以下几种方式：

1. 应用到方法上：在Controller类的方法上加上@ResponseBody注解，表示该方法的返回值将被写入HTTP响应体中。

@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
@ResponseBody
public User getUser(@PathVariable int id) {
    User user = userService.getUserById(id);
    return user;
}

? ? ? ? 2. 应用到方法的返回值上：如果不想在整个方法上加上@ResponseBody注解，可以只在方法的返回值上使用该注解。

@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
public @ResponseBody User getUser(@PathVariable int id) {
    User user = userService.getUserById(id);
    return user;
}

? ? ? ? 3. 应用到类上：在Controller类上加上@ResponseBody注解，表示该类的所有方法的返回值都将被写入HTTP响应体中。

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

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public User getUser(@PathVariable int id) {
        User user = userService.getUserById(id);
        return user;
    }

    // other methods...
}

使用@ResponseBody注解时，Spring MVC会根据请求的Content-Type头部和Accept头部来确定响应的内容类型。默认情况下，Spring MVC使用MappingJackson2HttpMessageConverter来将Java对象转换为JSON格式的数据。如果需要返回其他类型的数据，可以在Controller方法上使用其他的HttpMessageConverter注解进行指定。

需要注意的是，在使用@ResponseBody注解时，还需在Spring MVC配置文件中配置<mvc:annotation-driven />，以启用注解的支持。

5、数据库注解

5.1 @Entity

@Entity注解是JPA（Java Persistence API）中的一个注解，用于将Java类映射到数据库表。

使用@Entity注解的类将会被JPA框架视为一个实体类，实体类中的每个成员变量会被映射到数据库表中的一个字段。同时，实体类必须具有一个无参构造方法，以便JPA框架可以通过反射创建实例。

@Entity注解还可以与其他注解一起使用，来定义实体类与数据库表之间的映射关系。这些注解包括@Table、@Column、@Id等。

使用@Entity注解的一个简单示例如下：

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private int age;

    // 省略getter和setter方法
}

在上述示例中，@Entity注解表示Employee类是一个实体类，@Table注解指定了数据库表的名称为"employee"。@Id注解表示id字段是实体类的标识字段，@GeneratedValue注解指定了id字段的生成策略为自增长。@Column注解用于指定字段在数据库表中的名称。

@Entity注解的使用需要注意以下几点：

1. 实体类必须具有一个无参构造方法。
2. 实体类的成员变量必须使用private修饰，并且提供相应的getter和setter方法。
3. 实体类通过@Id注解来指定标识字段，通过@GeneratedValue注解来指定标识字段的值的生成策略。
4. 实体类使用@Table注解来指定数据库表的名称。
5. 实体类的成员变量使用@Column注解来指定字段在数据库表中的名称。

总之，@Entity注解是JPA框架中用于定义实体类的注解，它标识了一个Java类是一个实体类，并且与数据库表进行了映射。

5.2 @Table

@Table注解用于将一个实体类与数据库表进行映射。

使用方式如下：

1. 在实体类上添加@Table注解，指定表名和schema（可选）：

   @Table(name = "table_name", schema = "schema_name")
   public class MyEntity {
     // 实体类的属性和方法...
   }
   

2. 可以使用@Table注解的其他属性来进行更详细的配置：

   • name：指定表名，默认值为实体类名的小写形式。
   • schema：指定表所在的数据库模式（如MySQL中的数据库名），默认为空字符串。
   • catalog：指定表所在的数据库目录，默认为空字符串。
   • uniqueConstraints：指定表的唯一约束。
   • indexes：指定表的索引。

3. @Table注解还可以与其他注解一起使用，如@Id、@Column等注解，来进一步定义实体类与表的映射关系：

   @Entity
   @Table(name = "table_name")
   public class MyEntity {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     @Column(name = "id")
     private Long id;
   
     @Column(name = "name")
     private String name;
   
     // 其他属性和方法...
   }
   

注意事项：

• @Table注解通常与@Entity注解一起使用，用于指示实体类是一个JPA实体。
• 如果没有使用@Table注解，JPA默认会使用实体类的类名作为表名，并将其转换为小写形式。

5.3 @Column

@Column注解用于指定实体类中的字段与数据库表中的列的映射关系。它能够指定列名、数据类型、长度、是否允许为空、默认值等属性。

使用@Column注解需要注意以下几点：

1. 要使用@Column注解，需要先导入相关的包：javax.persistence.Column。

2. @Column注解可以放在字段上，也可以放在getter方法上。如果放在字段上，则该字段必须是private类型，如果放在getter方法上，则该getter方法必须存在。

3. name属性用于指定列名，默认为字段的名称。如 @Column(name = "age")。

4. nullable属性用于指定该字段是否允许为空，默认为true。如@Column(nullable = false)。

5. length属性用于指定字段的长度，默认值为255。如@Column(length = 20)。

6. unique属性用于指定该字段是否唯一，默认为false。如@Column(unique = true)。

7. columnDefinition属性用于指定字段的数据类型和约束条件。如@Column(columnDefinition = "varchar(50) not null default 'unknown'")。

示例：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "username", length = 20, nullable = false)
    private String username;
    
    @Column(name = "password", length = 50)
    private String password;
    
    // ...
    
    // Getter and Setter methods
}

在上面的示例中，username字段将被映射到数据库表中名为username的列，长度为20，不允许为空；password字段将被映射到数据库表中名为password的列，长度为50，允许为空。

使用@Column注解可以方便地控制实体类中字段与数据库表中列的映射关系，提供了灵活性和可读性。

5.4 @Id

@Id注解是用来标识一个实体类的唯一标识字段。在JPA（Java Persistence API）中，它通常被用来作为实体类的主键。

@Id注解可以应用在实体类的任何字段上，包括基本类型和引用类型。该注解可以与@GeneratedValue注解一起使用，用来指定主键的生成策略。

使用@Id注解的示例：

@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // getters and setters
}

在上面的示例中，@Id注解应用在id字段上，用来标识该字段是实体类的主键。并且通过@GeneratedValue注解指定了主键生成策略为IDENTITY，表示由数据库自动生成主键值。

在JPA中，还可以使用其他的主键生成策略，比如SEQUENCE、TABLE等，根据实际情况选择合适的策略。

需要注意的是，使用@Id注解的字段必须有对应的getter和setter方法，以便JPA能够正确地读取和写入字段的值。

总结来说，@Id注解用来标识实体类的主键字段，可以与@GeneratedValue注解一起使用来指定主键的生成策略。

5.5 @GeneratedValue

@GeneratedValue注解是用于生成实体类的唯一标识字段值的注解。

在JPA中，可以使用@GeneratedValue注解来指定生成主键值的策略。@GeneratedValue注解包含一个strategy属性，可以用来指定主键生成策略。常用的生成策略有：

• GenerationType.AUTO：由JPA自动选择适合的策略，默认为IDENTITY。
• GenerationType.IDENTITY：使用数据库的自增长字段生成主键。
• GenerationType.SEQUENCE：使用数据库的序列生成主键。
• GenerationType.TABLE：使用一个特定的数据库表格来生成主键。

@GeneratedValue注解可以用在实体类的主键字段或者普通字段上。当用在主键字段上时，会自动生成主键值；当用在普通字段上时，会自动生成一个全局唯一的值。

使用@GeneratedValue注解时，一般还需配合@Id注解来标识该字段为实体类的主键字段。

示例代码如下：

@Entity
@Table(name = "user")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    
    @Column(name = "username")
    private String username;
    
    // 省略getter和setter方法
}

在上述代码中，@GeneratedValue注解指定了使用JPA自动选择适合的策略来生成主键值。

5.6 @Repository

@Repository注解是Spring框架中的注解之一，用于标识一个类是数据访问层（DAO）的组件。

使用@Repository注解的类通常用于与数据库进行交互，包括执行SQL语句、持久化对象等操作。该注解的作用是告诉Spring框架，该类是一个数据访问层组件，并且需要被Spring管理和进行依赖注入。

@Repository注解的使用方法如下：

1. 在需要使用@Repository注解的类前添加注解声明，如：

@Repository
public class UserDao {
    // ...
}

? ? ? ? 2. 在Spring配置文件中声明对Repository组件的扫描，如：

<context:component-scan base-package="com.example.dao" />

这样，Spring就会自动扫描指定包下的所有@Repository注解的类，并将其实例化并管理。

@Repository注解还可以与其他注解一起使用，以进一步指定其功能。例如，可以与@Transactional注解一起使用，以在事务中使用该Repository组件。

总结： @Repository注解是Spring框架中用于标识数据访问层组件的注解，使用时需要在类前添加注解声明，并在Spring配置文件中进行相应的扫描配置。

6、事务注解

6.1 @Transactional

@Transactional注解是Spring框架中的一个注解，用于控制事务的行为。在Spring中，可以使用@Transactional注解来实现声明式事务管理。

@Transactional注解可以用在类级别和方法级别上。在类级别上使用注解，表示该类的所有方法都要应用事务管理；在方法级别上使用注解，表示该方法要应用事务管理。当使用@Transactional注解时，Spring会为带有该注解的方法自动开启一个事务，并在方法执行完毕后根据方法的执行结果，决定是提交事务还是回滚事务。

@Transactional注解有以下几个常用的属性：

• propagation：指定事务的传播行为，默认值为REQUIRED。可以设置的取值包括：

  • REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
  • SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
  • MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
  • REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则将当前事务挂起。
  • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，则将当前事务挂起。
  • NEVER：以非事务方式执行操作，如果当前存在事务，则抛出异常。
  • NESTED：如果当前存在事务，则在嵌套事务中执行；如果当前没有事务，则创建一个新的事务。

• isolation：指定事务的隔离级别，默认值为DEFAULT。可以设置的取值包括：

  • DEFAULT：使用数据库的默认隔离级别。
  • READ_UNCOMMITTED：读取未提交数据，可能导致脏读、不可重复读和幻读。
  • READ_COMMITTED：读取已提交数据，可以避免脏读，但可能导致不可重复读和幻读。
  • REPEATABLE_READ：可重复读取数据，可以避免脏读和不可重复读，但可能导致幻读。
  • SERIALIZABLE：串行化读取数据，可以避免脏读、不可重复读和幻读。

• timeout：指定事务的超时时间，默认值为-1，表示不设置超时时间。单位是秒。

• readOnly：指定事务是否为只读事务，默认值为false。如果设置为true，表示只读事务，不会对数据库的数据进行修改。

• rollbackFor：指定事务在遇到指定的异常时，回滚事务。可以设置为一个异常类型或异常类型的数组。

• noRollbackFor：指定事务在遇到指定的异常时，不回滚事务。可以设置为一个异常类型或异常类型的数组。

下面是使用@Transactional注解的一个例子：

@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
  
    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }
  
    @Override
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, readOnly = true)
    public User getUserById(int userId) {
        return userDao.getUserById(userId);
    }
    
    @Override
    @Transactional(rollbackFor = {Exception.class}, noRollbackFor = {RuntimeException.class})
    public void updateUser(User user) {
        userDao.updateUser(user);
    }
  
    @Override
    public void deleteUser(int userId) {
        userDao.deleteUser(userId);
    }
}

在上面的例子中，UserServiceImpl类的所有方法都会应用事务管理，因为它使用了@Transactional注解。其中，addUser方法和deleteUser方法的事务传播行为为默认值REQUIRED，isolation为默认值DEFAULT，readOnly为默认值false；getUserById方法的事务传播行为为REQUIRED，isolation为READ_COMMITTED，readOnly为true；updateUser方法的事务传播行为为默认值REQUIRED，isolation为默认值DEFAULT，readOnly为默认值false，同时还指定了rollbackFor属性和noRollbackFor属性。

6.2 @Propagation

@Propagation注解是Spring框架中的一个注解，用于在方法调用时控制事务的传播行为。它可以应用在带有@Transactional注解的方法上，用于指定事务的传播行为。

@Transactional注解用于定义方法的事务属性，其中的propagation属性用于指定事务的传播行为。默认情况下，事务的传播行为是REQUIRED，即如果当前存在事务，则加入该事务中，如果不存在事务，则创建一个新的事务。而@Propagation注解可以用来覆盖这个默认的传播行为。

@Propagation注解有以下几个取值：

• REQUIRED：如果当前存在事务，则加入该事务中，如果不存在事务，则创建一个新的事务。（这是默认的传播行为）
• REQUIRES_NEW：创建一个新的事务，并挂起当前事务，直到新事务完成。
• SUPPORTS：如果当前存在事务，则加入该事务中，如果不存在事务，则以非事务的方式执行。
• NOT_SUPPORTED：以非事务的方式执行操作，如果当前存在事务，则将当前事务挂起。
• MANDATORY：如果当前存在事务，则加入该事务中，如果不存在事务，则抛出异常。
• NEVER：以非事务的方式执行操作，如果当前存在事务，则抛出异常。

使用@Propagation注解的方式如下所示：

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void doSomething() {
    // 执行一些操作
}

在上述示例中，方法doSomething()会在一个新的事务中执行，而不管当前是否存在事务。

6.3 @Isolation

@Isolation 是一个用于将类或方法设置为独立运行的注解。当一个类或方法被标记为 @Isolation 时，它将在单独的线程中运行，以确保它不会受到其他并发操作的影响。

使用 @Isolation 注解可以提供以下优点：

1. 隔离性：通过将类或方法设置为独立运行，可以确保它不会受到其他并发操作的影响。这可以防止数据竞争和其他并发问题。

2. 安全性：由于被标记的类或方法在独立的线程中运行，因此可以防止其他线程对其进行干扰或修改。这可以提高系统的安全性。

3. 性能：通过将某些操作放在独立的线程中运行，可以提高系统的性能。例如，可以将一些耗时的计算或网络请求放在独立的线程中运行，以保持主线程的响应性能。

使用示例：

@Isolation
public class SomeClass {
    public void doSomething() {
        // 独立运行的代码块
    }
}

在上面的示例中，SomeClass 类被标记为 @Isolation，表示其中的 doSomething() 方法将在独立的线程中运行。这样可以确保该方法的执行不会受到其他并发操作的干扰。可以根据具体需求将其他需要隔离运行的类或方法标记为 @Isolation。

需要注意的是，@Isolation 注解仅表示该类或方法将在独立的线程中运行，并不能自动处理线程间通信和同步的问题。在使用 @Isolation 注解时，需要额外注意线程安全性和并发控制的问题。

6.4 @ReadOnly

@ReadOnly是一个Java注解，用于标记一个字段或方法，表示它们是只读的，即不允许修改。

使用@ReadOnly注解可以提供以下好处：

1. 类型检查：通过使用@ReadOnly注解，可以在编译时进行类型检查，以确保只读字段或方法不被意外修改。如果有任何尝试修改只读字段或方法的代码，编译器将抛出错误。

2. 文档说明：使用@ReadOnly注解可以使代码更易于理解和维护。其他开发人员可以明确知道哪些字段或方法是只读的，不应该修改它们。

3. 优化机会：通过将字段或方法标记为只读，编译器和运行时环境可以进行优化。例如，编译器可以进行常量折叠来消除对只读字段或方法的多个读取操作，从而提高性能。

使用@ReadOnly注解的示例：

public class ImmutableClass {
    @ReadOnly
    private final String name;

    public ImmutableClass(String name) {
        this.name = name;
    }

    @ReadOnly
    public String getName() {
        return name;
    }
}

在上面的示例中，name字段和getName()方法都使用了@ReadOnly注解。这表示它们是只读的，并且不应该被修改。如果有任何尝试修改它们的代码，编译器将抛出错误。

请注意，@ReadOnly注解只提供了一种标记字段或方法为只读的方式，并不会自动阻止对它们的修改。开发人员仍然需要遵守只读的约定，并确保不对这些字段或方法进行修改。

7、缓存注解

7.1 @Cacheable

@Cacheable注解用于将方法的结果缓存起来，以便在下次调用相同方法时可以直接从缓存中取值，而不需要再次执行方法。

使用@Cacheable注解时，可以指定一个缓存的名称和一个缓存键的生成策略。例如：

@Cacheable(value = "myCache", key = "#param")
public Object getResult(String param) {
    // method logic here...
}

上述代码将方法的返回结果缓存在名为"myCache"的缓存中，缓存键的生成策略是根据方法的参数param来生成的。

@Cacheable注解还可以指定条件，只有当满足条件时才会将方法的返回结果缓存起来。例如：

@Cacheable(value = "myCache", key = "#param", condition = "#result != null")
public Object getResult(String param) {
    // method logic here...
}

上述代码表示只有当方法的返回结果不为null时才会将结果缓存起来。

同时，@Cacheable注解还可以设置一个过期时间，表示缓存的数据在多长时间后失效。例如：

@Cacheable(value = "myCache", key = "#param", condition = "#result != null", expire = 600)
public Object getResult(String param) {
    // method logic here...
}

上述代码表示缓存的数据在600秒后失效。

需要注意的是，@Cacheable注解需要配合缓存管理器一起使用，以实现真正的缓存功能。可以通过配置文件或者代码的方式配置缓存管理器。另外，还需要确保使用了@Cacheable注解的方法始终返回相同类型的值，否则会导致缓存数据类型不一致的问题。

7.2 @CachePut

@CachePut注解用于将方法的返回值保存到缓存中。它主要用于在调用方法之前，检查缓存中是否已存在相应的键值对。如果存在，则不执行方法；如果不存在，则执行方法，并将返回值保存到缓存中。

使用@CachePut注解需要先配置一个缓存管理器，比如使用Spring提供的CacheManager或者其他缓存框架提供的缓存管理器。

下面是一个示例代码：

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @CachePut(value = "users", key = "#user.id")
    public User save(User user) {
        return userRepository.save(user);
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // ...
}

在上面的示例中，save方法使用了@CachePut注解来将返回值保存到名为"users"的缓存中，并以user对象的id作为缓存的键值。

需要注意的是，@CachePut注解与@Cacheable注解的区别在于，@CachePut注解总是执行方法，并将返回值保存到缓存中，而不去检查缓存中是否已存在相应的键值对。因此，@CachePut注解适合用于更新缓存的情况，比如更新数据库中的数据。

总结： @CachePut注解用于将方法的返回值保存到缓存中，常用于更新缓存的情况。使用@CachePut注解需要先配置一个缓存管理器，并且需要指定缓存的名称和键值。

7.3 @CacheEvict

@CacheEvict注解是Spring框架中的一个注解，用于清除缓存。它可以应用在方法上，表示该方法执行后将清除指定的缓存区域。

@CacheEvict注解的常用属性如下：

• value：指定要清除缓存的名称，可以是一个字符串或字符串数组。若不指定，则默认使用默认缓存管理器的名称。
• key：指定要清除的缓存项的键，支持SpEL表达式。若不指定，则会根据方法参数生成一个默认的键。
• condition：指定清除缓存的条件，支持SpEL表达式。只有当条件为真时，才会清除缓存。默认为空，表示无条件清除。
• allEntries：指定是否要清除缓存中的所有项。默认为false，表示只清除指定的键对应的缓存项。

以下是一个使用@CacheEvict注解的例子：

@Service
public class UserService {

    @CacheEvict(value = "users", key = "#id")
    public void deleteUserById(Long id) {
        // 执行删除用户的操作
    }

    @CacheEvict(value = "users", allEntries = true)
    public void deleteAllUsers() {
        // 执行删除所有用户的操作
    }

}

在上面的例子中，deleteUserById方法使用@CacheEvict注解清除了名为"users"的缓存区域中键为指定id的缓存项。deleteAllUsers方法使用@CacheEvict注解清除了名为"users"的缓存区域中的所有缓存项。

需要注意的是，@CacheEvict注解只能应用在有缓存注解（如@Cacheable、@CachePut）的方法上，否则无效。

8、定时任务注解

8.1 @Scheduled

@Scheduled注解是Spring框架提供的一个注解，用于定义定时任务。通过在方法上添加该注解，可以指定方法在特定的时间间隔内执行。

@Scheduled注解有几种使用方式：

1. 固定时间间隔执行：使用fixedRate属性，指定方法的执行间隔时间，单位是毫秒。
2. 固定延迟执行：使用fixedDelay属性，指定方法的执行间隔时间，单位是毫秒。与fixedRate不同的是，fixedDelay会等待上一个方法执行完成后再执行下一个方法。
3. cron表达式执行：使用cron属性，指定方法的执行时间，支持cron表达式的完整语法。

下面是一个使用@Scheduled注解的例子：

@Component
public class MyScheduledTask {
 
    @Scheduled(fixedRate = 5000)
    public void doTask() {
        // 方法要执行的操作
    }
 
    @Scheduled(fixedDelay = 5000)
    public void doAnotherTask() {
        // 方法要执行的操作
    }
 
    @Scheduled(cron = "0 0 12 * * ?")
    public void doCronTask() {
        // 方法要执行的操作
    }
}

在上面的例子中，MyScheduledTask类是一个Spring组件，使用@Component注解进行标记。在类中的方法上添加了@Scheduled注解，分别定义了三个定时任务方法。第一个doTask方法每隔5秒钟执行一次，第二个doAnotherTask方法等上一个方法执行完成后再等5秒钟执行，第三个doCronTask方法使用cron表达式指定每天中午12点执行一次。

需要注意的是，@Scheduled注解需要与@EnableScheduling注解一起使用，以启用Spring的定时任务功能。在Spring Boot应用中，可以直接在启动类上添加@EnableScheduling注解。

以上就是@Scheduled注解的详解和使用方法。通过使用该注解，可以轻松地定义和管理定时任务。

8.2 @EnableScheduling

@EnableScheduling是Spring框架中的一个注解，它用于启用定时任务的功能。在使用这个注解之前，我们需要先配置一个实现了SchedulingConfigurer接口的类，并在其中实现定时任务的相关逻辑。

@EnableScheduling注解的作用是告诉Spring框架，我们希望启用定时任务的功能，并且该注解可以用在Spring Boot应用程序的入口类上（通常是带有@SpringBootApplication注解的类）。

使用@EnableScheduling注解后，我们就可以在Spring应用程序中使用@Scheduled注解来定义定时任务。@Scheduled注解可以配置定时任务的执行时间、执行频率、执行逻辑等。

例如，下面是一个简单的示例：

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import import org.springframework.stereotype.Component;

@Component
@EnableScheduling
public class ScheduledTasks {

    @Scheduled(fixedRate = 5000)
    public void printMessage() {
        System.out.println("Hello, world!");
    }
}

在上面的示例中，我们定义了一个名为printMessage的定时任务，它会每5秒钟打印一次"Hello, world!"。

需要注意的是，@EnableScheduling注解只能用于标记Spring应用程序的入口类，并且定时任务的方法需要有public修饰符，否则无法被Spring框架识别。

总结一下，@EnableScheduling注解的作用是启用定时任务的功能，它可以用于标记Spring应用程序的入口类，并配合@Scheduled注解来定义定时任务的执行逻辑。

9、异步方法注解

9.1 @Async

@Async注解是Spring框架提供的一个用于实现异步方法调用的注解。

在需要实现异步调用的方法上加上@Async注解，就可以将该方法的执行交给一个单独的线程来处理，而当前线程可以继续执行其他操作。

使用@Async注解需要满足以下条件：

1. 需要在配置类中添加@EnableAsync注解，开启异步方法支持。
2. 需要在异步方法所在的类上添加@Component或@Service注解，使其能够被Spring框架扫描到。
3. 异步方法必须是public修饰的。

使用@Async注解的方法不能有返回值，如果需要返回结果，可以通过Future<T>对象来获取。

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

@Configuration
@EnableAsync
public class AppConfig {
}

@Service
public class MyService {

    @Async
    public void doSomething() {
        // 异步执行的逻辑
    }

    @Async
    public Future<String> doSomethingWithResult() {
        // 异步执行的逻辑
        return new AsyncResult<>("result");
    }
}

在上述示例中，doSomething方法和doSomethingWithResult方法被标注为@Async，因此它们的执行将在一个单独的线程中进行。

需要注意的是，使用@Async注解时要确保使用的是基于线程池的TaskExecutor，而不是SimpleAsyncTaskExecutor，因为SimpleAsyncTaskExecutor是每次调用都会创建一个新的线程，而线程池可以重用线程，性能更好。

除了上述示例中的方法级别的@Async注解，还可以在类级别上使用@Async注解，表示该类的所有方法都是异步的。

需要注意的是，@Async注解只有在使用@EnableAsync注解开启异步方法支持后才会生效。

10、条件注解

10.1 @Conditional

@Conditional注解是Spring框架提供的一个条件化注解，用于根据条件决定是否创建一个Bean。

使用@Conditional注解时，我们需要定义一个条件类，该类实现了Condition接口，并重写了其中的matches方法。matches方法返回一个boolean值，用于判断是否创建该Bean。

例如，我们定义一个条件类MyCondition：

public class MyCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 根据条件判断是否创建Bean
        // 返回true，则创建Bean；返回false，则不创建Bean
    }
}

然后我们可以在需要条件化创建Bean的地方使用@Conditional注解，指定我们定义的条件类：

@Configuration
public class MyConfiguration {

    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        // 创建Bean的逻辑
        return new MyBean();
    }
}

在上述例子中，只有当MyCondition.matches方法返回true时，才会创建MyBean对象并注入到Spring容器中。如果返回false，那么将不会创建MyBean对象。

@Conditional注解的使用场景非常广泛，可以用于动态创建Bean，根据不同的环境条件创建不同的Bean，或者根据某些配置属性创建Bean等等。它可以灵活的控制Bean的创建和销毁，使得应用程序的逻辑更加灵活和可配置。

11、配置注解

11.1 @Configuration

@Configuration是一个用来标识配置类的注解，表示该类是一个配置类，用于定义配置信息和创建Bean实例。

@Configuration注解通常与@Bean注解一起使用，使用@Bean注解的方法会被Spring容器托管，返回的对象会被添加到Spring容器中。可以使用@Configuration注解的类来替代XML配置文件，通过Java代码来配置Bean。

使用@Configuration注解的类通常有以下特点：

1. 该类必须被@ComponentScan扫描到，可以通过@ComponentScan注解指定扫描的包范围。
2. 使用@Bean注解的方法必须返回一个对象，Spring会将该对象添加到容器中。
3. 使用@Bean注解的方法可以有参数，参数可以使用@Autowired注解进行自动装配。

@Configuration注解的使用示例：

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

在上面的示例中，AppConfig类被@Configuration注解标识为配置类，使用@ComponentScan注解指定了需要扫描的包路径。另外，该类还定义了一个名为myBean的@Bean方法，用于创建一个MyBean对象，Spring会将该对象添加到容器中。

在使用@Configuration注解时需要注意以下几点：

1. @Configuration注解标识的类内部的@Bean方法不能在同一个类中调用，否则@Bean方法会失效。
2. 可以使用@Import注解来导入其他配置类，方便管理配置。
3. 可以使用@PropertySource注解来加载外部的配置文件。
4. 使用@ConfigurationProperties注解来绑定配置文件的属性到一个Bean中。

总之，使用@Configuration注解可以方便地替代XML配置文件，通过Java代码来配置Bean，提高了代码的可读性和维护性。

11.2 @Value

@Value注解是Spring框架中用于对字段进行赋值的注解。它可以用于类的属性上，也可以用于方法的参数上。

在类的属性上使用@Value注解，可以直接为属性赋值。例如：

@Component
public class MyBean {
    @Value("Hello World")
    private String message;
    
    //...
}

这里的message属性会被赋值为"Hello World"。可以看到，我们可以直接在@Value注解中指定属性的值。

除了直接指定属性的值，@Value注解还支持表达式的使用。例如：

@Component
public class MyBean {
    @Value("#{systemProperties['my.property']}")
    private String myProperty;
    
    //...
}

这里的myProperty属性会被赋值为系统属性my.property的值。

@Value注解还支持使用SpEL表达式。例如：

@Component
public class MyBean {
    @Value("#{T(java.lang.Math).random()}")
    private double randomNumber;
    
    //...
}

这里的randomNumber属性会被赋值为一个随机数。

在方法的参数上使用@Value注解，可以将注解的值作为方法的参数传入。例如：

@Component
public class MyBean {
    @Autowired
    private MyService myService;
    
    public void doSomething(@Value("Hello World") String message) {
        myService.printMessage(message);
    }
}

这里的doSomething方法的参数message会被赋值为"Hello World"，然后传递给myService的printMessage方法。

总结一下，@Value注解可以用于直接为字段赋值，支持直接指定值、使用表达式和SpEL表达式；也可以用于方法的参数上，将注解的值作为方法的参数传入。

11.3 @ConfigurationProperties

@ConfigurationProperties是Spring Boot提供的一个注解，用于将配置文件中的属性值映射到一个Java对象中。它可以用在任何Spring管理的Bean上，使这个Bean成为一个配置类。

使用@ConfigurationProperties注解的步骤如下：

1. 创建一个Java类，并在类上添加@ConfigurationProperties注解。这个类将用于映射配置文件中的属性。
2. 在类中定义与配置文件中属性对应的字段，并为这些字段提供getter和setter方法。
3. 在配置文件中设置属性的值。

举个例子，假设我们有一个配置文件application.properties，其中包含了以下属性：

myapp.name=My Application
myapp.version=1.0.0
myapp.description=This is a sample application.

我们可以创建一个类来映射这些属性：

@ConfigurationProperties(prefix = "myapp")
public class MyAppConfig {
    private String name;
    private String version;
    private String description;
    
    // getter and setter methods here...
}

在这个类中，我们使用了prefix = "myapp"来指定属性的前缀。使用这个前缀，我们可以将配置文件中的属性值映射到这个类的对应字段中。

然后，在我们的Spring Boot应用程序中，我们可以使用@Autowired注解将这个配置类注入到其他地方使用：

@Autowired
private MyAppConfig myAppConfig;

现在，我们就可以在代码中使用myAppConfig对象来访问配置文件中的属性了：

String appName = myAppConfig.getName();
String appVersion = myAppConfig.getVersion();
String appDescription = myAppConfig.getDescription();

@ConfigurationProperties还支持属性的校验和默认值设置。我们可以在字段上使用javax.validation.constraints注解来定义校验规则，例如：

@NotBlank(message = "Name cannot be blank")
private String name;

同时，我们也可以为字段提供默认值，当配置文件中没有为该字段设置值时，将使用默认值：

private String name = "Default Name";

总之，@ConfigurationProperties注解是一个非常方便的工具，可以帮助我们轻松地将配置文件中的属性值映射到Java对象中。这样做可以使我们的代码更加清晰和可维护。

12、AOP注解

AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，它将程序的功能分为核心关注点和横切关注点。核心关注点是指程序的主要业务逻辑，而横切关注点是指与核心关注点相关的功能，例如日志记录、性能监控等。

在Java中，AOP可以通过使用注解来实现。注解是一种用于给Java代码添加元数据的标记，它可以用于编译时进行静态检查，也可以在运行时进行动态处理。通过使用注解，我们可以定义切点、切面和通知。

• 切点（Pointcut）：切点是指程序中的一个特定位置，在这个位置上我们可以插入横切关注点。切点可以通过注解来定义，例如使用@Pointcut注解。

• 切面（Aspect）：切面是一个包含横切逻辑的类，它定义了在切点上执行的通知。切面可以通过注解来定义，例如使用@Aspect注解。

• 通知（Advice）：通知是在切点上执行的代码，它定义了在何时、何地以及如何执行横切逻辑。通知可以是前置、后置、返回、异常和环绕五种类型，它们分别对应着在切点之前、之后、返回结果时、抛出异常时和围绕切点执行。

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

@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before advice: " + joinPoint.getSignature().getName());
    }
    
    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("After returning advice: " + joinPoint.getSignature().getName() + ", result: " + result);
    }
    
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception exception) {
        System.out.println("After throwing advice: " + joinPoint.getSignature().getName() + ", exception: " + exception.getMessage());
    }
    
    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Before around advice: " + proceedingJoinPoint.getSignature().getName());
        
        Object result = proceedingJoinPoint.proceed();
        
        System.out.println("After around advice: " + proceedingJoinPoint.getSignature().getName() + ", result: " + result);
        
        return result;
    }
}

在上述示例中，我们定义了一个切面类LoggingAspect，并使用@Aspect注解将其标记为切面。接着，在切面类中定义了四个通知方法，分别对应着@Before、@AfterReturning、@AfterThrowing和@Around注解。这些注解用于指定切点表达式和通知类型。

在通知方法中，我们可以通过JoinPoint参数获取到切点的相关信息，例如方法的签名和参数。在@AfterReturning和@AfterThrowing通知中，我们还可以通过returning和throwing参数获取到方法的返回值和抛出的异常。在@Around通知中，我们需要使用ProceedingJoinPoint参数，并调用proceed()方法来继续执行被切入的方法。

最后，我们需要在配置文件中启用AOP，例如使用@EnableAspectJAutoProxy注解启用自动代理。

通过使用AOP注解，我们可以很方便地在程序中插入横切逻辑，例如日志记录、权限验证等。它可以提高代码的可维护性和可测试性，同时还能够减少重复的代码。

13、测试注解

13.1 @RunWith

@RunWith注解是JUnit框架的一个注解，用于指定测试类的运行器（Runner）。Runner是一个类，负责执行测试类中的测试方法。

@RunWith注解用法如下：

@RunWith(Runner.class)
public class MyTest {
    // 测试方法
    @Test
    public void myTestMethod() {
        // ...
    }
}

@RunWith注解的参数是一个Runner类，常用的Runner类有以下几种：

1. JUnitCore：默认的Runner，用于在命令行或IDE中运行JUnit测试。
2. BlockJUnit4ClassRunner：用于运行JUnit4风格的测试类。
3. Parameterized：用于运行参数化测试。

示例：

@RunWith(Parameterized.class)
public class MyParameterizedTest {
    // 参数化测试方法
    @Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            { 1, "A" },
            { 2, "B" },
            { 3, "C" }
        });
    }

    private int value;
    private String expected;

    public MyParameterizedTest(int value, String expected) {
        this.value = value;
        this.expected = expected;
    }

    @Test
    public void test() {
        // ...
    }
}

在上面的示例中，@RunWith(Parameterized.class)注解告诉JUnit使用Parameterized运行器来运行MyParameterizedTest类。@Parameters注解告诉Parameterized运行器参数化的方式，这样JUnit会根据data()方法返回的参数运行多次测试方法。

13.2 @SpringBootTest

@SpringBootTest是Spring Boot中的一个注解，用于标记一个测试类为Spring Boot的测试类。它的作用是创建一个Spring应用程序上下文，以便在测试期间使用。通过使用@SpringBootTest注解，我们可以在测试中使用Spring的各种功能和组件。

使用@SpringBootTest注解的语法如下：

@SpringBootTest
public class MyTest {
    // 测试方法
}

@SpringBootTest注解有以下几个参数可以设置：

• classes：指定Spring Boot应用程序的主配置类。如果不指定，默认会尝试去寻找一个带有@SpringBootApplication注解的类作为主配置类。
• properties：指定Spring应用程序的配置文件路径。
• webEnvironment：指定Web环境的类型。默认值是WebEnvironment.MOCK，表示使用模拟的Web环境。其他可选值有WebEnvironment.RANDOM_PORT（随机端口）和WebEnvironment.DEFINED_PORT（定义的端口）。
• randomPort：一个布尔值，表示是否使用随机端口。默认值是false。
• definedPort：一个整数值，表示使用的定义端口。默认值是0，表示随机选择一个空闲端口。
• initializers：指定Spring应用程序的初始化器。

使用@SpringBootTest注解时，需要确保classpath中包含了Spring Boot的依赖。通常，我们会在测试类中使用@RunWith注解指定JUnit运行器，并使用@SpringBootTest注解标记测试类。

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

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest {
    @Autowired
    private MyService myService;

    @Test
    public void test() {
        // 测试逻辑
    }
}

在上面的示例中，@RunWith注解用于指定JUnit的运行器为SpringRunner，@SpringBootTest用于标记测试类。在测试方法中，我们通过@Autowired注解注入一个MyService的实例，以便在测试逻辑中使用。

总结来说，@SpringBootTest是Spring Boot中用于标记测试类的注解，它的作用是创建一个Spring应用程序上下文，以便在测试期间使用Spring的功能和组件。

13.3 @MockBean

@MockBean是Spring Boot中用于创建Mock对象的注解之一。它可以用来创建一个指定类型的Mock对象，并将其注册到Spring应用程序的上下文中。

@MockBean注解通常与@SpringBootTest一起使用，用于创建一个集成测试环境，其中包含真实的Spring应用程序上下文和一些模拟的bean。

以下是@MockBean注解的使用示例：

@SpringBootTest
public class MyServiceTest {

    @Autowired
    private MyService myService;

    @MockBean
    private MyRepository myRepository;

    @Test
    public void testFindById() {
        // Arrange
        when(myRepository.findById(1L)).thenReturn(Optional.of(new MyEntity(1L, "test")));

        // Act
        MyEntity result = myService.findById(1L);

        // Assert
        assertEquals("test", result.getName());
    }
}

在上面的示例中，@MockBean注解用来创建一个名为myRepository的Mock对象，并将其注册到Spring应用程序上下文中。然后，可以使用Mockito的when方法来设置myRepository模拟对象的行为。

这样，我们就可以在集成测试中使用模拟对象来模拟依赖关系的行为，以及进行各种测试操作。

需要注意的是，@MockBean注解只能在测试类中使用，用于创建Mock对象并将其注入到Spring上下文中。在其他非测试类中，应该使用@Mock注解来创建Mock对象。

14、安全注解

14.1 @EnableWebSecurity

@EnableWebSecurity是一个Spring Security提供的注解，用于启用Web安全功能。使用@EnableWebSecurity注解，可以自定义配置Spring Security的行为。

使用@EnableWebSecurity注解的步骤如下：

1. 在Spring Boot项目的配置类上加上@EnableWebSecurity注解。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   // ...配置方法
}

? ? ? ? 2. 创建一个继承自WebSecurityConfigurerAdapter的配置类，该类用于配置Spring Security的行为。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
   @Override
   protected void configure(HttpSecurity http) throws Exception {
       // 配置http请求的安全规则
       http.authorizeRequests()
           .antMatchers("/admin/**").hasRole("ADMIN")
           .antMatchers("/user/**").hasAnyRole("ADMIN", "USER")
           .anyRequest().authenticated()
           .and()
           .formLogin().permitAll()
           .and()
           .logout().permitAll();
   }
   
   @Override
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
       // 配置用户认证的逻辑
       auth.inMemoryAuthentication()
           .withUser("admin").password("{noop}admin123").roles("ADMIN")
           .and()
           .withUser("user").password("{noop}user123").roles("USER");
   }
   
}

在上面的配置中，configure(HttpSecurity http)方法用于配置http请求的安全规则。通过调用http.authorizeRequests()方法，可以指定不同URL路径对应的访问权限。antMatchers("/admin/").hasRole("ADMIN")表示所有以"/admin/"开头的URL需要ADMIN角色才能访问，antMatchers("/user/").hasAnyRole("ADMIN", "USER")表示所有以"/user/"开头的URL需要ADMIN或USER角色才能访问。anyRequest().authenticated()表示其他任意URL都需要进行认证才能访问。formLogin().permitAll()表示使用表单登录，并且允许所有用户进行登录。logout().permitAll()表示允许所有用户进行登出操作。

configure(AuthenticationManagerBuilder auth)方法用于配置用户认证的逻辑。在上面的例子中，通过调用auth.inMemoryAuthentication()方法，可以在内存中创建用户并配置角色和密码。{noop}表示不加密密码，只是为了演示方便。

通过以上步骤，就可以使用@EnableWebSecurity注解启用Web安全功能，并且自定义配置Spring Security的行为。

14.2 @Secured

@Secured注解是Spring Security框架提供的一个注解，用于对方法进行权限控制。它可以添加在Controller的方法上，定义需要哪些角色或权限才能访问该方法。

使用@Secured注解，需要在配置类上添加@EnableGlobalMethodSecurity注解，并设置securedEnabled为true，以开启对方法级别的安全控制。

@Secured注解的参数是一个角色或权限的数组，表示只有拥有该角色或权限的用户才能访问被注解的方法。多个角色或权限可以通过逗号隔开。

例如，下面的代码示例演示了如何使用@Secured注解来限制只有ROLE_ADMIN角色的用户才能访问被注解的方法：

@RestController
@RequestMapping("/admin")
public class AdminController {

    @Secured("ROLE_ADMIN")
    @GetMapping("/users")
    public List<User> getUsers() {
        // 返回用户列表
    }

    @Secured({"ROLE_ADMIN", "ROLE_SUPERADMIN"})
    @PostMapping("/user")
    public ResponseEntity<String> addUser(@RequestBody User user) {
        // 添加用户
    }
}

在上面的例子中，"/admin/users"接口只有拥有ROLE_ADMIN角色的用户才能访问，而"/admin/user"接口则要求用户同时拥有ROLE_ADMIN和ROLE_SUPERADMIN角色才能访问。

需要注意的是，@Secured注解只能用于角色或权限的控制，无法实现更复杂的访问控制逻辑。如果需要更灵活的控制，可以使用@PreAuthorize或@PostAuthorize注解。

14.3 @PreAuthorize

@PreAuthorize注解是Spring Security提供的一种权限验证注解，用于在方法执行之前对用户的权限进行验证。它可以用于控制方法的访问权限，只有满足指定条件的用户才能调用该方法。

使用@PreAuthorize注解时，需要在方法前添加该注解，并在注解中指定权限表达式。权限表达式是一个字符串，可以使用SpEL（Spring表达式语言）来编写，用于判断用户是否有访问该方法的权限。

以下是@PreAuthorize注解的使用示例：

@PreAuthorize("hasRole('ADMIN')")
public void adminMethod() {
    // 操作代码
}

@PreAuthorize("hasAnyRole('ADMIN', 'USER')")
public void userMethod() {
    // 操作代码
}

在上面的示例中，adminMethod()方法使用@PreAuthorize注解，并指定权限表达式为hasRole('ADMIN')，意味着只有具有ADMIN角色的用户才能调用该方法。而userMethod()方法使用@PreAuthorize注解，并指定权限表达式为hasAnyRole('ADMIN', 'USER')，意味着只要具有ADMIN或USER角色的用户就可以调用该方法。

@PreAuthorize注解还支持其他权限判断条件，如hasAuthority()、hasAnyAuthority()、isAuthenticated()、permitAll()、denyAll()等，可以根据具体需求进行使用。

需要注意的是，@PreAuthorize注解只能用于Spring容器中被Spring Security管理的方法上，也就是说该方法必须是由Spring框架创建的Bean。

15、结语

????????文章至此，已接近尾声！希望此文能够对大家有所启发和帮助。同时，感谢大家的耐心阅读和对本文档的信任。在未来的技术学习和工作中，期待与各位大佬共同进步，共同探索新的技术前沿。最后，再次感谢各位的支持和关注。您的支持是作者创作的最大动力，如果您觉得这篇文章对您有所帮助，请考虑给予一点打赏。