SpringBoot 常用注解

一、Spring MVC 相关注解

1、@RequestMapping

（1）功能：
　　将 HTTP 请求 与 请求处理类中的方法 进行映射。
　　通过 RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter 两个类来支持该注解。

（2）常用参数：
　　value： 用于保存请求的 URL
　　method： 用于指定当前请求的方法，比如：PUT，GET，DELETE，POST 等。

（3）用法举例：
　　使用之前需要 通过 @RestController 或者 @Controller 注解标记类。
如下例所示：
　　@RequestMapping 可以对类、方法进行标记，使用时会自动拼接。
　　并根据不同的请求方法（method），找到相对应的请求处理方法。

@RestController
@RequestMapping("/api")
public class EmpController {

    @RequestMapping(value = "/emp/{id}", method = RequestMethod.GET)
    public Result selectOne(@PathVariable(name = "id") Integer id) {
        return Result.ok();
    }
    
    @RequestMapping(value = "/emp", method = RequestMethod.POST)
    public Result createEmp(@RequestBody Emp emp) {
        return Result.ok();
    }
    
    @RequestMapping(value = "/emp{id}", method = RequestMethod.DELETE)
    public Result deleteById(@PathVariable(name = "id") Integer id) {
        return Result.ok();
    }
    
    @RequestMapping(value = "/emp{id}", method = RequestMethod.PUT)
    public Result updateEmp(@PathVariable(name = "id") Integer id, @RequestBody Emp emp) {
        return Result.ok();
    }
}

2、@GetMapping

（1）功能：
　　用于处理 HTTP 的 GET 请求。
　　本质是 @RequestMapping(method = RequestMethod.GET)。

（2）举例：
　　@RequestMapping(value = "/emp/{id}", method = RequestMethod.GET)
等价于
　　@GetMapping("/emp/{id}")

@RestController
@RequestMapping("/api")
public class EmpController {

    @GetMapping("/emp/{id}")
    public Result selectOne(@PathVariable(name="id") Integer id) {
        return Result.ok();
    }

}

3、@PostMapping

（1）功能：
　　用于处理 HTTP 的 POST 请求。
　　本质是 @RequestMapping(method = RequestMethod.POST)。

（2）举例：
　　@RequestMapping(value = "/emp", method = RequestMethod.POST)
等价于
　　@PostMapping("/emp")

@RestController
@RequestMapping("/api")
public class EmpController {

    @PostMapping("/emp")
    public Result createEmp(@RequestBody Emp emp) {
        return Result.ok();
    }

}

4、@PutMapping

（1）功能：
　　用于处理 HTTP 的 PUT 请求。
　　本质是：@RequestMapping(method = RequestMethod.PUT)。

（2）举例：
　　@RequestMapping(value = "/emp{id}", method = RequestMethod.PUT)
等价于
　　@PutMapping("/emp{id}")

@RestController
@RequestMapping("/api")
public class EmpController {

    @PutMapping("/emp{id}")
    public Result updateEmp(@PathVariable(name = "id") Integer id, @RequestBody Emp emp) {
        return Result.ok();
    }
}

5、@DeleteMapping

（1）功能：
　　用于处理 HTTP 的 DELETE 请求。
　　本质是：@RequestMapping(method = RequestMethod.DELETE)。

（2）举例：
　　@RequestMapping(value = "/emp{id}", method = RequestMethod.DELETE)
等价于
　　@DeleteMapping("/emp{id}")

@RestController
@RequestMapping("/api")
public class EmpController {

    @DeleteMapping("/emp{id}")
    public Result deleteById(@PathVariable(name = "id") Integer id) {
        return Result.ok();
    }
}

6、@PathVariable

（1）功能：
　　用于将请求地址中的模板变量 绑定到 请求处理类的方法的 参数上。
　　请求地址中 使用 {} 包裹模板变量名。
　　请求处理方法中 使用 @PathVariable 来获取该模板变量名。

（2）常用参数：
　　name 给参数取别名，等同于 value
　　value 给参数取个别名，等同于 name
　　require 如果参数是非必须项，将其设为 false，默认为 true

（3）举例：
　　如下例，通过 @PathVariable 绑定模板变量。
　　使用 name 属性后，变量名可以自定义，可以不同于 模板变量名。
即两种方式：
　　@PathVariable(name="id") Integer id2
或者
　　@PathVariable(Integer id)

@RestController
@RequestMapping("/api")
public class EmpController {

    @GetMapping("/emp/{id}")
    public Result selectOne(@PathVariable(name="id") Integer id2) {
        return Result.ok();
    }

}

7、@RequestBody

（1）功能：
　　用于处理请求参数列表，将其映射到一个对象中。
　　根据请求参数名 与 对象属性名 进行匹配并绑定值（只有匹配成功才会绑定值）。
　　请求参数通过 HttpMessageConverter 进行传递。

（2）举例：
　　如下例，会将请求参数列表 映射 到 emp 这个对象中。

@RestController
@RequestMapping("/api")
public class EmpController {

    @PostMapping("/emp")
    public Result createEmp(@RequestBody Emp emp) {
        return Result.ok();
    }

}

8、@ResponseBody

（1）功能：
　　用于处理请求方法的返回值，将其写入 HTTP 的响应中。
注：
　　@RestController 内部包含了 @ResponseBody 和 @Controller，所以使用 @RestController 注解时，不需要再添加 @ResponseBody 注解。

（2）举例：
　　如下例，将 createEmp 返回值写入 HTTP 响应中（一般为 JSON 数据）。

@Controller
@ResponseBody 
@RequestMapping("/api")
public class EmpController {

    @PostMapping("/emp")
    public Result createEmp(@RequestBody Emp emp) {
        return Result.ok();
    }

}

9、@RestControllerAdvice、@ControllerAdvice

（1）功能：
　　可以用来处理全局异常、数据绑定、数据预处理。
　　全局异常需要与 @ExceptionHandler 注解一起使用。
　　数据绑定需要与 @ModelAttribute 注解一起使用。
　　数据预处理需要与 @InitBinder 注解一起使用。
注：
　　@RestControllerAdvice 注解包含了 @ControllerAdvice 与 @ResponseBody 注解。

全局异常处理：
　　https://www.cnblogs.com/l-y-h/p/12781586.html#_label2
数据绑定、数据预处理：
　　https://www.cnblogs.com/lenve/p/10748453.html

（2）举例：
　　如下例：通过 @RestControllerAdvice 注解标记一个全局异常处理类，
　　当异常发生时，@ExceptionHandler 可以捕获到相应的异常信息，从而进行处理。

@RestControllerAdvice
public class GlobalExceptionHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 处理 Exception 异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(Exception.class)
    public Result handlerException(Exception e) {
        logger.error(e.getMessage(), e);
        return Result.error().message("系统异常");
    }

    /**
     * 处理空指针异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(NullPointerException.class)
    public Result handlerNullPointerException(NullPointerException e) {
        logger.error(e.getMessage(), e);
        return Result.error().message("空指针异常");
    }
}

10、@ExceptionHandler

（1）功能;
　　用于标注 处理指定异常的方法，当异常发生时，Spring 捕获异常并将异常传递给 @ExceptionHandler 注解标记的方法，从而进行处理。

（2）举例：
　　与上例代码相同，此处不重复粘贴。

11、@RequestParam

（1）功能：
　　用于将请求体中的数据 绑定到 请求处理类的方法的 参数上。
注：
　　可以通过 @PathVariable 获取请求地址上的参数。
　　可用通过 @RequestParam 获取请求体中的参数。

（2）常用参数：
　　defaultValue 当参数为空时，可以设置一个默认值。
　　其余参数与 @PathVariable 相同。

（3）举例：
　　如下例，访问地址 http://localhost:8080/emp/selectOne/3?id2=2 时，
　　@PathVariable   获取到的就是 3
　　@RequestParam   获取到的就是 2

@RestController
@RequestMapping("/api")
public class EmpController {

    @GetMapping("/selectOne/{id}")
    public Result selectOne(@PathVariable Integer id, @RequestParam Integer id2) {
        return Result.ok();
    }

}

12、@Controller、@RestController

（1）功能：
　　是 @Component 注解的一个延伸。
　　用于标注 Spring MVC 的控制器，Spring 自动扫描并配置该注解标注的类。
注：
　　@RestController 内部包含了 @ResponseBody 和 @Controller，所以使用 @RestController 注解时，不需要再添加 @ResponseBody 注解。

（2）举例：
　　上面的代码中都有体现，此处不重复粘贴。

二、Spring Bean 注解

Spring 注解配置 Bean 参考地址：
　　https://www.cnblogs.com/l-y-h/p/11342174.html

1、@ComponentScan

（1）功能：
　　此注解 用于指定需要被 Spring 扫描到的类。
　　通过 basePackages 或者 value 属性指定 需要扫描的包路径。

（2）举例：
　　如下例：为 SpringBoot 注解标记 @SpringBootApplication 的内容。

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}

2、@Component、@Repository、@Service

（1）功能：
　　@Component 用于标注一个普通的组件类，没有明确业务的范围，只是表示需要被 Spring 扫描并管理。

（2）@Component 功能延伸（明确业务范围）
　　@Controller 用于标注一个控制类（用于控制层组件）。
　　@Service 用于标注一个业务处理类（用于业务层组件）。
　　@Repository 用于标注一个数据持久类（用于数据持久层组件）。

（3）举例：
　　如下例，为 @Service 注解的内容。

@Component
public @interface Service {
   @AliasFor(annotation = Component.class)
   String value() default "";
}

3、@Bean

（1）功能：
　　将所标注的类纳入到 Spring 的 Bean 管理工厂中。

（2）常用属性：
　　initMethod                     用于指定初始化方法
　　destroyMethod              用于指定销毁方法

（3）举例：
　　如下例，将 TestBean 纳入 Bean 管理工厂中，项目一启动，会默认加载。

@SpringBootApplication
public class TestEasycodeApplication {

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

    @Bean(initMethod ="initBean", destroyMethod = "destoryBean")
    public TestBean testBean() {
        return new TestBean();
    }
}

class TestBean {
    public void initBean() {
        System.out.println("============ hello ==============");
    }
    public void destoryBean() {
        System.out.println("============ destory ============");
    }
}

4、@DependsOn

（1）功能：
　　在 Spring IOC 初始化一个 Bean 前，先初始化其他的 Bean 对象。

（2）举例：
　　如下例，如果没有 指定 @DependsOn 时，会按照顺序从上而下初始化。
　　但是指定后，会先初始化指定的 Bean。

@SpringBootApplication
public class TestEasycodeApplication {

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

    @Bean(value = {"testBean"}, initMethod ="initBean", destroyMethod = "destoryBean")
    @DependsOn(value = {"testDependsOn"})
    public TestBean testBean() {
        return new TestBean();
    }

    @Bean(value = {"testDependsOn"}, initMethod ="initBean", destroyMethod = "destoryBean")
    public TestDependsOn testDependsOn() {
        return new TestDependsOn();
    }
}

class TestBean {
    public void initBean() {
        System.out.println("============ Bean hello ==============");
    }
    public void destoryBean() {
        System.out.println("============ Bean destory ============");
    }
}

class TestDependsOn {
    public void initBean() {
        System.out.println("============ Depends On hello ==============");
    }
    public void destoryBean() {
        System.out.println("============ Depends On destory ============");
    }
}

5、@Scope

（1）功能：
　　用来定义 @Component、@Bean 标记的类的作用范围。

（2）常用范围：
　　singleton 单例模式，每次获取的都是同一个对象
　　prototype 原型模式，每次获取的都是不同的对象

（3）举例：
　　如下例，Bean 指定为 单例模式，则 IOC 容器中只存在一个该类的对象，每次调用时，都是同一个对象。

@Bean(value = {"testBean"}, initMethod ="initBean", destroyMethod = "destoryBean")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public TestBean testBean() {
    return new TestBean();
}

6、@Autowired、@Qualifier

（1）功能：
　　用于标记 Spring 将要解析和注入 的依赖项。
　　简单地理解：将 Spring 容器的对应的内容注入到此注解标记的位置。

（2）举例：
　　@Autowired 默认按照类型去匹配。
　　若想按照名称去匹配，则需要通过 @Qualifier 注解一起使用（常用于同一个类型存在多个 Bean 对象的情况）。

@Autowired
@Qualifier("computer")
private Computer computer;

三、JSR-250 注解

1、@Resource

（1）功能：

　　其功能等同于 @Autowired，用来自动注入，但是其默认按照名称去匹配。

（2）常用参数：
　　name            指定 bean 名称去匹配
　　type             指定 bean 类型去匹配

（3）举例：

import javax.annotation.Resource;

private Computer computer;

@Resource
private Phone phone;  //插入类型为Phone的对象

@Resource  //注入bean对象
public void setComputer(Computer computer) {
    this.computer = computer;
}

2、@PostConstruct、@PreDestroy

（1）功能：
　　@PostConstruct 注解用来标记 Bean 的初始化方法。
　　@PreDestroy 注解用来标记 Bean 的销毁方法。
　　类似于 @Bean 中的 initMethod、destoryMethod 属性。

（2）举例：

package com.test;
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class ExampleBean {
    public void execute() {
        System.out.println("执行execute处理方法1");
    }
 
    @PostConstruct //等价于<bean init-method="init">
    public void init() {
        System.out.println("初始化");
    }

    @PreDestroy  //等价于<bean destory-method="destory">
    public void destory() {
        System.out.println("释放资源");
    }
}    

四、SpringBoot 注解

1、@SpringBootApplication

（1）功能：
　　是一个快捷的配置注解，被该注解标记的类中，可以定义一个或多个 Bean，并触发自动配置 Bean 和 扫描组件。
　　其为 @ComponentScan、@EnableAutoConfiguration、@Configuration 的组合注解。

（2）举例：
　　如下例，为 SpringBoot 启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class TestEasycodeApplication {

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

2、@Configuration

（1）功能：
　　此注解用于定义配置类，可用于替换 xml 配置文件（作用等同于 xml 配置文件），该注解标记的内部可以包含一个或多个 @Bean 声明的方法，并由 Spring 容器进行管理。

（2）举例：
　　如下例，Configuration 注解内部 是一个 Component 注解。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
   @AliasFor(annotation = Component.class)
   String value() default "";
   boolean proxyBeanMethods() default true;
}

3、@EnableAutoConfiguration

（1）功能：
　　此注解用于通知 Spring，根据当前类路径引入的 jar 依赖包，自动配置与这些依赖包相关的配置项。

（2）举例：
　　如下例，为 EnableAutoConfiguration 注解的内容。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

   String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
   Class<?>[] exclude() default {};
   String[] excludeName() default {};
}

4、@Conditional 相关注解

（1）功能：
　　@Conditional 注解可以根据一些自定义条件动态选择是否加载 某个 Bean 到 Spring IOC 容器中去。

（2）常见注解：
@ConditionalOnClass 与 @ConditionalOnMissingClass：
　　根据某些类作为判断依据，从而决定是否执行某个操作。
　　比如 @ConditionalOnClass， 当指定的 class 在类路径上时，才去实例化一个 Bean 到容器中。

@ConditionalOnBean 与 @ConditionalOnMissingBean：
　　根据某对象作为判断依据，从而决定是否执行某个操作。
　　比如 @ConditionalOnBean， 当指定的对象存在时，才去实例化一个 Bean 到容器中。

@ConditionalOnProperty：
　　根据某个配置文件是否满足配置项作为判断依据，从而决定是否执行某个操作。

@ConditionalOnResource
　　根据某个配置文件是否存在作为判断依据，从而决定是否执行某个操作。

@ConditionalExpression
　　根据表达式作为判断依据，从而决定是否执行某个操作。
　　比如：表达式为 true 时，才会实例化一个 Bean 到容器中。

（3）举例：
　　如下例，为 redis 的配置（Redis backed session configuration.）。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ RedisTemplate.class, RedisIndexedSessionRepository.class })
@ConditionalOnMissingBean(SessionRepository.class)
@ConditionalOnBean(RedisConnectionFactory.class)
@Conditional(ServletSessionCondition.class)
@EnableConfigurationProperties(RedisSessionProperties.class)
class RedisSessionConfiguration {

   @Bean
   @ConditionalOnMissingBean
   ConfigureRedisAction configureRedisAction(RedisSessionProperties redisSessionProperties) {
      switch (redisSessionProperties.getConfigureAction()) {
      case NOTIFY_KEYSPACE_EVENTS:
         return new ConfigureNotifyKeyspaceEventsAction();
      case NONE:
         return ConfigureRedisAction.NO_OP;
      }
      throw new IllegalStateException(
            "Unsupported redis configure action '" + redisSessionProperties.getConfigureAction() + "'.");
   }

   @Configuration
   public static class SpringBootRedisHttpSessionConfiguration extends RedisHttpSessionConfiguration {

      @Autowired
      public void customize(SessionProperties sessionProperties, RedisSessionProperties redisSessionProperties) {
         Duration timeout = sessionProperties.getTimeout();
         if (timeout != null) {
            setMaxInactiveIntervalInSeconds((int) timeout.getSeconds());
         }
         setRedisNamespace(redisSessionProperties.getNamespace());
         setFlushMode(redisSessionProperties.getFlushMode());
         setSaveMode(redisSessionProperties.getSaveMode());
         setCleanupCron(redisSessionProperties.getCleanupCron());
      }

   }

}