当前位置：首页 > news >正文

注解定义自定义注解，常见（spring springboot springcloud）

news 来源：原创 2025/5/8 21:20:17

定义自定义注解

元注解

示例代码

使用自定义注解

通过反射获取注解信息

常见的注解

Spring注解

组件扫描与 Bean 定义

@Component、@Controller、@Service和@Repository区别

AOP

Springmvc注解

控制器相关注解

请求映射注解

请求参数注解

响应相关注解

异常处理注解

Post 接口，用 get 请求，收到的状态码是多少？

405 Method Not Allowed

400 Bad Request

500 Internal Server Error

301 Moved Permanently 或 302 Found

@RequestParam

@RequestParam VS @PathVariable区别

1. 参数位置

2. 参数必要性

3. 参数类型

4. 使用场景

Springboot注解

启动类注解

配置文件注解

SpringCloud常用标签

服务发现相关注解

@EnableEurekaClient

@EnableDiscoveryClient

服务调用相关注解

@FeignClient

熔断相关注解

@EnableCircuitBreaker

@HystrixCommand

配置管理相关注解

@RefreshScope

网关路由相关注解

@EnableZuulProxy

@EnableGateway

Spring Cloud Alibaba

服务发现与注册：Nacos

@EnableDiscoveryClient

分布式配置管理：Nacos Config

@RefreshScope

熔断与限流：Sentinel

@SentinelResource

分布式事务：Seata

@GlobalTransactional

消息驱动：RocketMQ

@RocketMQMessageListener

负载均衡：Spring Cloud LoadBalancer

@LoadBalanced

在 Java 里，自定义注解可以借助 @interface 关键字来创建。注解本质上是一种特殊的接口，它能为代码元素（像类、方法、字段等）添加额外信息。下面会详细阐述自定义注解的定义、使用、元注解以及示例代码。

定义自定义注解

使用 @interface 关键字来定义一个注解，语法如下：

public @interface 注解名 {
    // 注解属性
    数据类型 属性名() default 默认值;
}

注解属性的类型可以是基本数据类型、String、Class、枚举类型、注解类型，或者是这些类型的数组。若不设置 default 值，那么在使用注解时就必须为该属性赋值。

元注解

元注解是用于注解注解的注解，Java 提供了几个元注解，用于指定自定义注解的使用范围和生命周期等信息：

@Retention：指定注解的保留策略，有 RetentionPolicy.SOURCE（只在源代码中保留，编译时会被丢弃）、RetentionPolicy.CLASS（编译时保留在字节码中，但运行时不可用）和 RetentionPolicy.RUNTIME（运行时保留，可通过反射获取）。
@Target：指定注解可以应用的目标元素类型，如 ElementType.TYPE（类、接口、枚举）、ElementType.METHOD（方法）、ElementType.FIELD（字段）等。
@Documented：将注解包含在 JavaDoc 中。
@Inherited：允许子类继承父类的注解。

示例代码

以下是一个自定义注解的示例，该注解用于标记方法的执行时间统计：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 定义一个自定义注解，用于标记需要统计执行时间的方法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExecutionTime {
    // 定义一个属性，用于指定是否记录详细信息，默认值为 false
    boolean logDetails() default false;
}

上述代码定义了一个名为 ExecutionTime 的注解，它可以应用于方法上，并且有一个 logDetails 属性，默认值为 false。

使用自定义注解

下面是使用 ExecutionTime 注解的示例：

public class MyService {

    // 使用 ExecutionTime 注解标记该方法，指定 logDetails 为 true
    @ExecutionTime(logDetails = true)
    public void doSomething() {
        try {
            // 模拟方法执行，线程休眠 2 秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，MyService 类的 doSomething 方法使用了 ExecutionTime 注解，并将 logDetails 属性设置为 true。

通过反射获取注解信息

可以通过反射机制在运行时获取注解信息，以下是一个示例：

import java.lang.reflect.Method;

public class AnnotationProcessor {
    public static void main(String[] args) throws NoSuchMethodException {
        // 获取 MyService 类的 Class 对象
        Class<?> clazz = MyService.class;
        // 获取 doSomething 方法的 Method 对象
        Method method = clazz.getMethod("doSomething");
        // 检查方法是否有 ExecutionTime 注解
        if (method.isAnnotationPresent(ExecutionTime.class)) {
            // 获取 ExecutionTime 注解的实例
            ExecutionTime annotation = method.getAnnotation(ExecutionTime.class);
            // 输出 logDetails 属性的值
            System.out.println("Log details: " + annotation.logDetails());
        }
    }
}

在上述代码中，AnnotationProcessor 类通过反射获取 MyService 类的 doSomething 方法，并检查该方法是否有 ExecutionTime 注解。如果有，则获取注解的实例并输出 logDetails 属性的值。

综上所述，自定义注解能够为代码添加额外的元数据，并且可以在运行时通过反射机制获取这些元数据，从而实现一些特定的功能，如日志记录、权限验证等。

更全面参考：

https://zhuanlan.zhihu.com/p/60730622

常见的注解

Spring注解

组件扫描与 Bean 定义

@Component 组件，没有明确的角色

@Service 在业务逻辑层使用（service层）

@Repository 在数据访问层使用（dao层）

@Controller 在展现层使用，控制器的声明（C）

依赖注入：@Autowired：由Spring提供 @qualifier 定义名称

当存在多个相同类型的 Bean 时，@Autowired 无法确定具体注入哪个 Bean，此时可以使用 @Qualifier 注解指定要注入的 Bean 的名称。

@Qualifier

如果一个接口有多个实现，那么注入时候加上唯一标示

作用：与@Autowired结合使用，用于指定具体的 Bean 名称进行依赖注入。当有多个类型相同的 Bean 可供选择时，可以使用@Qualifier来明确指定要注入的 Bean。
使用场景：当自动装配存在多个候选 Bean 时，使用@Qualifier指定具体的 Bean 名称以消除歧义。

@Resource：由java提供

默认按照名称进行注入，如果找不到匹配的名称，则按照类型进行注入。

@Bean 使用在方法上，声明当前方法的返回值存入spring容器中。

@Scope 标注bean的范围【Singleton 默认，Prototype 原型】

@ComponentScan 用于指定spring初始化容器时要扫描的包

@Import 使用@import导入的类会被spring加载到IOC容器中

@Component、@Controller、@Service和@Repository区别

都是 Spring 框架中的注解

@Component是一个通用的组件注解，用于标记任何 Spring 可以管理的类，将其定义为一个 Spring 组件。它是最基础的注解，其他三个注解在某种程度上是对@Component的细化。当一个类被标记为@Component时，Spring 会扫描到它，并将其纳入 Spring 容器管理，可用于实现一些通用的功能模块，这些模块没有明确的分层界限。

@Controller主要用于定义 Spring MVC 中的控制器类，用于处理 HTTP 请求。它是一种特殊的 @Component，专门用于构建 Web 应用程序的前端交互逻辑。@Controller类中的方法通常会结合@RequestMapping等请求映射注解，将 HTTP 请求路径与方法进行关联，使得外部请求能够被正确接收和处理，并且返回结果给客户端。

@Service用于标记业务逻辑层的类。它明确地将一个类定义在业务逻辑层面，强调该类包含业务相关的操作。在实际应用中，@Service类通常会调用@Repository标记的数据访问层类来获取数据，然后进行业务处理。这有助于在复杂的业务场景中，清晰地划分和管理不同层次的功能，方便开发人员对业务逻辑的维护和扩展。

@Repository用于标注数据访问层的类，比如操作数据库的 DAO（Data Access Object）类。除了具有将类纳入 Spring 容器管理的功能外，它还提供了额外的功能，如自动将数据访问层的原生异常转换为 Spring 的统一数据访问异常，这使得在处理数据访问异常时，代码更加整洁和统一，提高了整个数据访问层的健壮性。

AOP

@Aspect、@Before、@After、@Around、@pointcut 用于切面编程

@Aspect：用于标识一个切面类，该类中可以定义切入点和通知。

@Aspect
@Component
public class LoggingAspect {
    // 切入点和通知的定义
}

@Before：前置通知注解，用于在目标方法执行之前执行指定的增强逻辑。

@Before("execution(* com.example.service.*.*(..))")
public void beforeAdvice() {
    // 前置通知的逻辑
}

@After：后置通知注解，无论目标方法是否正常执行结束，都会在目标方法执行之后执行指定的增强逻辑。

@After("execution(* com.example.service.*.*(..))")
public void afterAdvice() {
    // 后置通知的逻辑
}

@Around：环绕通知注解，它可以在目标方法执行前后都进行增强处理，并且可以控制目标方法是否执行。

@Around("execution(* com.example.service.*.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    // 前置处理
    Object result = joinPoint.proceed();
    // 后置处理
    return result;
}

用于配置

@Configuration：

功能：用于定义配置类，代替传统的 XML 配置文件来配置 Spring 容器。

标注了这个注解的类内部可以使用@Bean注解来定义 Bean。

示例：@Configuration public class AppConfig {...}定义了一个 Spring 配置类。

@PropertySource：

功能：用于加载外部的属性文件，通常用于配置数据库连接信息、

应用程序的配置参数等。

示例：@PropertySource("classpath:application.properties")

public class AppConfig {...}加载了application.properties文件。

Springmvc注解

Spring MVC 提供了一系列注解，这些注解能极大简化 Web 应用开发过程，下面从不同功能维度为你介绍 Spring MVC 常用注解。

控制器相关注解

@Controller：用于标识一个类为 Spring MVC 的控制器，它是 @Component 的特殊化注解，被 Spring 框架扫描并注册为 Bean，处理 HTTP 请求。

@Controller
public class UserController {
    // 控制器方法
}

@RestController：这是 @Controller 和 @ResponseBody 的组合注解。使用 @RestController 注解的类，其所有方法返回的数据会直接作为响应体输出，常用于构建 RESTful API。

@RestController
public class UserRestController {
    // RESTful API 方法
}

请求映射注解

@RequestMapping：可用于类和方法上，用于将 HTTP 请求映射到控制器的处理方法。它能指定请求的 URL、请求方法（GET、POST 等）、请求参数等。

@GetMapping：是 @RequestMapping(method = RequestMethod.GET) 的快捷方式，专门用于处理 HTTP GET 请求。

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Long id) {
        // 返回用户信息
        return new User();
    }
}

@PostMapping：@RequestMapping(method = RequestMethod.POST) 的快捷方式，用于处理 HTTP POST 请求，常用来创建资源。

@RestController
@RequestMapping("/users")
public class UserController {
    @PostMapping
    public User createUser(@RequestBody User user) {
        // 创建用户的逻辑
        return user;
    }
}

@PutMapping：@RequestMapping(method = RequestMethod.PUT) 的快捷方式，处理 HTTP PUT 请求，通常用于更新资源。

@RestController
@RequestMapping("/users")
public class UserController {
    @PutMapping("/{id}")
    public User updateUser(@PathVariable("id") Long id, @RequestBody User user) {
        // 更新用户信息的逻辑
        return user;
    }
}

@DeleteMapping：@RequestMapping(method = RequestMethod.DELETE) 的快捷方式，处理 HTTP DELETE 请求，用于删除资源。

@RestController
@RequestMapping("/users")
public class UserController {
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable("id") Long id) {
        // 删除用户的逻辑
    }
}

请求参数注解

@PathVariable：用于获取 URL 中的路径变量。

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Long id) {
        // 根据路径变量 id 获取用户信息
        return new User();
    }
}

@RequestParam：用于获取请求参数，可处理 GET 请求的查询参数或 POST 请求的表单参数。

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping
    public List<User> getUsers(@RequestParam(value = "name", required = false) String name) {
        // 根据请求参数 name 查询用户列表
        return new ArrayList<>();
    }
}

@RequestBody：用于将请求体中的数据绑定到方法的参数上，常用于处理 JSON 或 XML 格式的数据。

@RestController
@RequestMapping("/users")
public class UserController {
    @PostMapping
    public User createUser(@RequestBody User user) {
        // 根据请求体中的用户信息创建用户
        return user;
    }
}

@RequestHeader：用于获取请求头中的信息。

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping
    public String getUsers(@RequestHeader("User-Agent") String userAgent) {
        // 获取请求头中的 User-Agent 信息
        return userAgent;
    }
}

@CookieValue：用于获取请求中的 Cookie 值。

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping
    public String getUsers(@CookieValue("JSESSIONID") String sessionId) {
        // 获取请求中的 JSESSIONID Cookie 值
        return sessionId;
    }
}

响应相关注解

@ResponseBody：用于将方法的返回值直接作为响应体返回给客户端，常用于返回 JSON 或 XML 数据。

@Controller
public class UserController {
    @GetMapping("/users/{id}")
    @ResponseBody
    public User getUser(@PathVariable("id") Long id) {
        // 返回用户信息作为响应体
        return new User();
    }
}

@ResponseStatus：用于设置 HTTP 响应状态码。

@RestController
@RequestMapping("/users")
public class UserController {
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable("id") Long id) {
        // 删除用户的逻辑
    }
}

异常处理注解

@ExceptionHandler：用于处理控制器中抛出的异常。

@Controller
public class UserController {
    @GetMapping("/users/{id}")
    public String getUser(@PathVariable("id") Long id) {
        if (id < 0) {
            throw new IllegalArgumentException("Invalid user ID");
        }
        return "user";
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public String handleIllegalArgumentException(IllegalArgumentException e) {
        // 处理 IllegalArgumentException 异常
        return "error";
    }
}

@ControllerAdvice：用于定义全局异常处理类，结合 @ExceptionHandler 可以处理所有控制器中抛出的异常。

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public String handleException(Exception e) {
        // 处理所有异常
        return "error";
    }
}

@RequestMapping	用于映射请求路径，可以定义在类上和方法上。用于类上，则表示所有方法都以该地址作为父路径
@GetMapping	Spring MVC 注解，用来映射 GET 请求，它是一个组合注解，相当于 @RequestMapping(method = RequestMethod.GET) 。
@PostMapping	Spring MVC 注解，用来映射 POST 请求，它是一个组合注解，相当于 @RequestMapping(method = RequestMethod.POST) 。
@RequestParam	请求参数的名称
@PathVariable	从请求路径下中获取请求参数{/user/{id}},传递给方法的形式参数
@RequestHeader	获取请求头信息
@CookieValue	获取cookie
@RequestBody	接收前端传过来的json对象，将json转为java对象
@ResponseBody	返回json对象响应给客户端
@RestController	@Controller +@ResponseBody

@RequestMapping （value=’’,method={RequestMethod。GET或者POSt}）绑定url

@RequestParam (value=’’ required=false)绑定参数,将客户端请求中的参数值映射到相应方法的参数上;

Post 接口，用 get 请求，收到的状态码是多少？

405

405 Method Not Allowed

含义：此状态码表明客户端使用的请求方法（这里是 GET）不被目标资源所允许。服务器知道客户端请求的资源，但不支持使用当前的请求方法来访问该资源。
示例：在 Java 的 Spring MVC 框架中，若一个控制器方法使用 @PostMapping 注解来处理 POST 请求，当客户端发送 GET 请求时，服务器就会返回 405 状态码。

400 Bad Request

含义：该状态码表示客户端发送的请求存在语法错误或无法被服务器理解。虽然 GET 请求本身没有语法错误，但有些服务器可能会将不恰当的请求方法视为一种错误的请求，从而返回 400 状态码。
示例：在一些自定义的服务器实现中，可能会对请求方法进行严格的验证，如果发现请求方法不符合接口的预期，就会返回 400 状态码。

500 Internal Server Error

含义：这表示服务器在处理请求时发生了内部错误，无法完成请求。出现这种情况可能是因为服务器端的代码逻辑存在问题，没有正确处理不匹配的请求方法。
示例：若服务器端代码在处理请求时没有对请求方法进行有效的检查，直接尝试按照 POST 请求的逻辑处理 GET 请求，可能会导致程序抛出异常，最终返回 500 状态码。

301 Moved Permanently 或 302 Found

含义：这两个状态码表示重定向。在某些特殊情况下，服务器可能会将 GET 请求重定向到另一个合适的资源或接口，从而返回 301 或 302 状态码。不过这种情况相对较少，通常是服务器端为了引导用户到正确的资源而进行的设置。

@RequestParam

将请求参数绑定到你控制器的方法参数上（是springmvc中接收普通参数的注解）

语法：@RequestParam(value=”参数名”,required=”true/false”,defaultValue=””)

value：参数名

required：是否包含该参数，默认为true，表示该请求路径中必须包含该参数，如果不包含就报错。

defaultValue：默认参数值，如果设置了该值，required=true将失效，自动为false,如果没有传该参数，就使用默认值

@RequestParam VS @PathVariable区别

1. 参数位置

@RequestParam：主要用于获取请求的查询参数（GET 请求的 URL 后面的参数部分，或 POST 请求的表单参数）。查询参数通常以键值对的形式出现在 URL 的问号后面，多个参数之间用 & 分隔。
@RequestParam：/manongyanjiuseng?age=18&name="zxh“”

// 请求 URL: /users?name=John&age=25
@GetMapping("/users")
public String getUsers(@RequestParam("name") String name, @RequestParam("age") int age) {
    // 处理逻辑
    return "users";
}

@PathVariable：用于获取 URL 路径中的变量。路径变量是 URL 的一部分，通常用于标识资源的唯一标识符。

// 请求 URL: /users/123
@GetMapping("/users/{id}")
public String getUser(@PathVariable("id") Long id) {
    // 处理逻辑
    return "user";
}

2. 参数必要性

@RequestParam：参数的必要性可以通过 required 属性进行控制。required 属性默认为 true，表示该参数是必需的，如果请求中没有提供该参数，会抛出 MissingServletRequestParameterException 异常；若将 required 属性设置为 false，则该参数是可选的。

@GetMapping("/users")
public String getUsers(@RequestParam(value = "name", required = false) String name) {
    // 处理逻辑
    return "users";
}

@PathVariable：路径变量是 URL 的一部分，通常是必需的。如果 URL 中没有包含对应的路径变量，请求将无法匹配到相应的处理方法。

3. 参数类型

@RequestParam：可以处理多种类型的参数，包括基本数据类型、字符串、数组、集合等。Spring MVC 会自动将请求参数转换为方法参数的类型。

@GetMapping("/users")
public String getUsers(@RequestParam("ids") List<Long> ids) {
    // 处理逻辑
    return "users";
}

@PathVariable：同样可以处理多种类型的参数，但需要注意的是，路径变量的值通常是字符串类型，Spring MVC 会尝试将其转换为方法参数的类型。如果转换失败，会抛出 TypeMismatchException 异常。

@GetMapping("/users/{id}")
public String getUser(@PathVariable("id") Long id) {
    // 处理逻辑
    return "user";
}

4. 使用场景

@RequestParam：适用于传递可选的、用于筛选或查询的参数。例如，在搜索功能中，用户可以根据不同的条件进行搜索，这些条件可以作为查询参数传递。

@GetMapping("/search")
public String search(@RequestParam(value = "keyword", required = false) String keyword,
                     @RequestParam(value = "category", required = false) String category) {
    // 处理搜索逻辑
    return "searchResults";
}

@PathVariable：适用于标识资源的唯一标识符，如用户 ID、文章 ID 等。通过路径变量可以方便地定位到具体的资源。

@GetMapping("/articles/{articleId}")
public String getArticle(@PathVariable("articleId") Long articleId) {
    // 处理获取文章逻辑
    return "article";
}

综上所述，@RequestParam 和 @PathVariable 在参数位置、必要性、类型和使用场景上都存在明显的区别，开发者需要根据具体的需求选择合适的注解来获取请求参数。

Springboot注解

启动类注解

@SpringBootApplication：这是一个组合注解，包含了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 三个注解的功能。它用于标记 Spring Boot 应用的主类，启动 Spring Boot 应用时会自动进行组件扫描和自动配置。

@Configuration表明这个类是一个配置类，可以在其中定义 Bean 和配置信息。@EnableAutoConfiguration自动配置 Spring Boot 应用，根据类路径中的依赖和配置，自动配置相关的组件，例如，当引入了 Spring Data JPA 依赖，会自动配置 JPA 相关的内容。@ComponentScan: 组件扫描，可自动发现和装配一些Bean。( web开发的同学一定都有用过会装配标识了@Controller，@Service，@Repository，@Component注解的类到spring容器中。）

@RestController

@Controller和@ResponseBody的组合，用于定义 RESTful 风格的控制器，方法的返回值会直接转换为 JSON 或其他格式并返回给客户端，无需再使用@ResponseBody单独标注方法。@RequestMapping用于映射 HTTP 请求路径到控制器的方法，它可以定义在类级别和方法级别，类级别的@RequestMapping定义了一个基本路径，方法级别的@RequestMapping在基本路径基础上进一步细化路径。

配置文件注解

@Value：用于从配置文件（如 application.properties 或 application.yml）中获取配置值并注入到 Bean 的字段中。

@Component
public class MyConfig {
    @Value("${my.property}")
    private String myProperty;
    // 其他方法
}

@ConfigurationProperties：用于将配置文件中的属性批量绑定到一个 Java Bean 中，通常与 @EnableConfigurationProperties 一起使用。

@ConfigurationProperties(prefix = "my")
public class MyProperties {
    private String property;
    // getter 和 setter 方法
}

@SpringBootApplication
@EnableConfigurationProperties(MyProperties.class)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@Value（“${}”）可以注入properties里面的配置项

Spring boot application.properties配置的属性的值。

@Conditional 条件化注解

@ConditionalOnBean(A.class)仅仅在当前上下文中存在A对象时，才会实例化一个Bean，

@ConditionalOnMissingBean（A.class）仅仅在当前上下文中不存在A对象时，才会实例化一个Bean

@ConditionalOnWebApplication

@Scheduled，按指定执行周期执行方法

@CrossOrigin 可以处理跨域请求，让你能访问不是一个域的文件;

@Import 导入其他配置类

@ImportResource 和@Import类似，区别就是@ImportResource导入的是配置文件

@Enable*注解说明,这些注解主要用来开启对xxx的支持。

@Transactional （readOnly=true）注解式事务

@TransactionalEventListener用于配置事务的回调方法，可以在事务提交前、提交后、完成后

@EnableWebMvc 在配置类中开启Web MVC的配置支持，如一些ViewResolver或者MessageConverter等，若无此句，重写WebMvcConfigurerAdapter方法（用于对SpringMVC的配置）。

@EnableAutoConfiguration 打开自动配置

@EnableAspectJAutoConfiguration用于自动配置 AspectJ 切面相关的内容，开启 Spring Boot 对 AspectJ 的支持。

@EnableAspectJAutoProxy 开启对AspectJ自动代理的支持

@EnableWebMvc 开启Web MVC的配置支持

@EnableConfigurationProperties 开启对@ConfigurationProperties注解配置Bean的支持

@EnableJpaRepositories 开启对SpringData JPA Repository的支持

@EnableTransactionManagement 开启注解式事务的支持

@EnableCaching 开启注解式的缓存支持

@EnableScheduling，开启定时任务功能

@EnableAsync，开启方法异步执行的能力，通过@Async或者自定义注解找到需要异步执行的方法。通过实现AsyncConfigurer接口的

getAsyncExecutor()和getAsyncUncaughtExceptionHandler()方法自定义Executor和异常处理。

@Async，标记方法为异步线程中执行

@EnableConfigurationProperties，启动@ConfigurationProperties功能

@EnableCaching 注解自动化配置合适的缓存管理器。

@EnableWebSecurity 注解开启spring security的功能，集成websercrityconfigureadapter。

swagger

@ApiOperation 首先@ApiOperation注解不是Spring自带的，它是是swagger里的注解@ApiOperation是用来构建Api文档的@ApiOperation(value = “接口说明”, httpMethod = “接口请求方式”, response = “接口返回参数类型”, notes = “接口发布说明”；

SpringCloud常用标签

服务发现相关注解

`@EnableEurekaClient`

作用：在 Spring Cloud Eureka 中，用于标记一个服务为 Eureka 客户端，使其能够将自身服务信息注册到 Eureka 服务注册中心，同时也可以从该中心获取其他服务的信息。
示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.client.EnableEurekaClient;

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

`@EnableDiscoveryClient`

作用：这是一个通用的服务发现客户端注解，可用于不同的服务发现组件（如 Eureka、Consul、Zookeeper 等），使用该注解的服务会自动注册到配置好的服务发现中心。
示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

服务调用相关注解

`@FeignClient`

作用：在 Spring Cloud OpenFeign 中，用于定义一个 Feign 客户端接口，通过声明式的方式调用远程服务。Feign 会根据接口的定义自动生成代理对象，将 HTTP 请求封装成方法调用。
示例代码：

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/users")
    String getUsers();
}

熔断相关注解

`@EnableCircuitBreaker`

作用：用于启用 Spring Cloud Circuit Breaker 熔断器功能，开启后可以对服务调用进行熔断保护，防止因某个服务故障导致整个系统崩溃。
示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;

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

`@HystrixCommand`

作用：在使用 Netflix Hystrix 熔断器时，用于标记一个方法为熔断方法，并可以指定熔断后的降级方法。当被标记的方法调用失败时，会自动调用降级方法返回备用结果。
示例代码：

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @HystrixCommand(fallbackMethod = "fallbackGetUser")
    public String getUser(String id) {
        // 模拟调用远程服务
        throw new RuntimeException("Service call failed");
    }

    public String fallbackGetUser(String id) {
        return "Default user info";
    }
}

配置管理相关注解

`@RefreshScope`

作用：在 Spring Cloud Config 中，当配置发生变化时，使用 @RefreshScope 注解的 Bean 可以在不重启应用的情况下刷新配置。
示例代码：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

@Component
@RefreshScope
@ConfigurationProperties(prefix = "myconfig")
public class MyConfig {
    private String property;

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }
}

网关路由相关注解

`@EnableZuulProxy`

作用：在 Spring Cloud Zuul 中，用于启用 Zuul 代理功能，将 Zuul 作为 API 网关，对请求进行路由和过滤。
示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

`@EnableGateway`

作用：在 Spring Cloud Gateway 中，用于启用 Spring Cloud Gateway 功能，创建一个基于响应式编程的 API 网关。
示例代码：

@EnableAdminServer 使用admin监控应用。

@EnableHystrix表示启动断路器，断路器依赖于服务注册和发现。

@HystrixCommand注解方法失败后，系统将西东切换到fallbackMethod方法执行。指定回调方法

@RefreshScope　如果代码中需要动态刷新配置，在需要的类上加上该注解就行。但某些复杂的注入场景下，这个注解使用不当，配置可能仍然不动态刷新;

@FeignClient springboot调用外部接口:声明接口之后，在代码中通过@Resource注入之后即可使用。@FeignClient标签的常用属性如下：name：指定FeignClient的名称，如果项目使用了Ribbon，name属性会作为微服务的名称，用于服务发现

@EnableCircuitBreaker 开启断路器功能

@LoadBalanced 开启客户端负载均衡

@RibbonClient，这个注解用来为负载均衡客户端做一些自定义的配置，可以进一步配置或自定义从哪里获取服务端列表、负载均衡策略、Ping也就是服务鉴活策略等等

@InitBinder 一般用于controller 可以将所以form 讲所有传递进来的string 进行html编码，防止xss攻击，比如可以将字符串类型的日期转换成date类型

https://blog.csdn.net/u014666697/java/article/details/90756644

Spring Cloud Alibaba

是 Spring Cloud 生态体系下的一个子项目，它为分布式应用开发提供了一系列组件和工具，下面为你介绍 Spring Cloud Alibaba 中一些常用的注解。

服务发现与注册：Nacos

`@EnableDiscoveryClient`

作用：此注解并非 Spring Cloud Alibaba 特有，但在使用 Nacos 作为服务注册与发现中心时经常会用到。它能让应用将自身注册到 Nacos 服务中心，同时也可以从 Nacos 中获取其他服务的实例信息。
示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

分布式配置管理：Nacos Config

`@RefreshScope`

作用：在使用 Nacos 进行分布式配置管理时，当 Nacos 中的配置发生变化，使用 @RefreshScope 注解的 Bean 可以在不重启应用的情况下刷新配置。
示例代码：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

@Component
@RefreshScope
@ConfigurationProperties(prefix = "myconfig")
public class MyConfig {
    @Value("${my.property}")
    private String property;

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }
}

熔断与限流：Sentinel

`@SentinelResource`

作用：该注解用于标记需要进行限流、熔断、降级等流量控制的资源。可以指定资源名称、限流降级规则、异常处理方法等。
示例代码：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @SentinelResource(value = "myResource", blockHandler = "handleBlock")
    public String doSomething() {
        return "Normal response";
    }

    public String handleBlock(BlockException ex) {
        return "Blocked by Sentinel: " + ex.getClass().getSimpleName();
    }
}

分布式事务：Seata

`@GlobalTransactional`

作用：在使用 Seata 进行分布式事务管理时，使用 @GlobalTransactional 注解可以将一个方法标记为全局事务的入口点，Seata 会自动管理该方法及其调用的其他服务方法的事务一致性。
示例代码：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @GlobalTransactional
    @Transactional
    public void createOrder() {
        // 创建订单的业务逻辑
    }
}

消息驱动：RocketMQ

`@RocketMQMessageListener`

作用：用于标记一个类为 RocketMQ 消息监听器，指定监听的主题、消费组等信息，当有消息到达指定主题时，该监听器会处理消息。
示例代码：

import com.alibaba.rocketmq.spring.annotation.RocketMQMessageListener;
import com.alibaba.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Service;

@Service
@RocketMQMessageListener(topic = "myTopic", consumerGroup = "myConsumerGroup")
public class MyMessageListener implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

负载均衡：Spring Cloud LoadBalancer

虽然 Spring Cloud LoadBalancer 不是 Spring Cloud Alibaba 特有的组件，但在 Spring Cloud Alibaba 生态中也会使用到，它和 Nacos 等组件配合实现服务的负载均衡。通常结合 @LoadBalanced 注解使用。

`@LoadBalanced`

作用：在使用 RestTemplate 或 WebClient 进行服务调用时，使用 @LoadBalanced 注解可以让 Spring Cloud LoadBalancer 为请求自动选择合适的服务实例进行负载均衡。
示例代码：

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}