SpringBoot是一个快速开发框架，能够快速的将一些常用的第三方依赖整合，简化了xml配置，全部采用注解形式，内置Http服务器（Jetty和Tomcat），最终以Java应用程序执行。现在基于SpringBoot平台开发的项目数不胜数，与常规的基于Spring开发的项目最大的不同之处，SpringBoot 里面提供了大量的注解用于快速开发，而且非常简单，基本可以做到开箱即用！

1、配置相关注解

1.1 @SpringBootApplication

每个SpringBoot程序都有一个主入口，也就是main方法，main里面调用SpringApplication.run()启动整个spring-boot程序，该方法所在类需要使用@SpringBootApplication注解，以及@ImportResource注解(if need)。@SpringBootApplication 注解是 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan这3个注解的集合体，等价于同时使用 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan这3个注解。

@SpringBootConfiguration(内部为@Configuration)：被标注的类等于在spring的XML配置文件中(applicationContext.xml)，装配所有bean事务，提供了一个spring的上下文环境。
@EnableAutoConfiguration：SpringBoot根据应用所声明的依赖来对Spring框架进行自动配置。
@ComponentScan：组件扫描，可自动发现和装配Bean，默认扫描SpringBootApplication注解类所在的包路径下文件，所以最好将该启动类放到根包路径下。

@SpringBootApplication
public class PropertyApplication {

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

把@SpringBootApplication换成@Configuration、@EnableAutoConfiguration、@ComponentScan这三个注解，一样可以启动成功，@SpringBootApplication只是将这三个注解进行了简化！

1.2 @ComponentScan

组件扫描，相当于spring xml配置文件中的 <context:component-scan>，标注哪些路径下的类需要被Spring扫描，用于自动发现和装配一些Bean对象。如扫描到有@Component、@Controller、@Service等这些注解的类，则把这些类注册为bean。

该注解默认配置是扫描当前文件夹下和子目录下的所有类，如果我们想指定扫描某些包路径，可以按以下方式处理。

@ComponentScan(basePackages = {"com.xxx.a", "com.xxx.b", "com.xxx.c"})

1.3 @Configuration

声明一个 Java 形式的配置类(指出该类是 Bean 配置的信息源)，相当于XML中的 <beans></beans> ，SpringBoot 提倡基于 Java 的配置，比如声明一个配置类AppConfig，然后初始化一个Uploader对象。

@Configuration
public class AppConfig {

    @Bean
    public Uploader uploader() {
        return new OSSUploader();
    }

}

1.4 @SpringBootConfiguration

@SpringBootConfiguration 是SpringBoot项目的配置注解，这也是一个组合注解，可以替代 @Configuration 注解。@SpringBootConfiguration 注解可以用java代码的形式实现spring中xml配置文件配置的效果，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中，并且实例名就是方法名。

注解源码

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

1.5 @Bean

用 @Bean 标注方法等价于XML中配置的bean，意思是产生一个 bean 对象，并交给spring管理，示例代码如下：

@Configuration
public class AppConfig {
	 
    //相当于 xml 中配置 Bean
    @Bean
    public Uploader uploader() {
        return new OSSUploader();
    }

}

1.6 @EnableAutoConfiguration

@EnableAutoConfiguration 让 SpringBoot 根据应用所声明的依赖来对 Spring 框架进行自动配置，一般加在主类上。通俗说就是帮助SpringBoot应用将所有符合条件的 @Configuration 配置类，全部都加载到当前 SpringBoot 里，并创建对应配置类的Bean，同时把该Bean实体交给IoC容器进行管理。

某些场景下，如果我们想要避开某些配置类的扫描（包括避开一些第三方jar包下面的配置，可以使用exclude参数。

@Configuration
@EnableAutoConfiguration(exclude = { org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class
})
public class AppConfig {

    //具有业务方法
}

1.7 @EnableTransactionManagement

表示开启事务支持，等同于 xml 配置方式的 <tx:annotation-driven />。

@SpringBootApplication
@EnableTransactionManagement
public class PropertyApplication {

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

1.8 @Conditional

从 Spring4 开始，可以通过@Conditional注解实现按条件装载bean对象，目前 Spring Boot 源码中大量扩展了@Condition注解，用于实现智能的自动化配置，满足各种使用场景。下面给大家列举几个常用的注解：

@ConditionalOnBean：当某个特定的Bean存在时，配置生效
@ConditionalOnMissingBean：当某个特定的Bean不存在时，配置生效
@ConditionalOnClass：当Classpath里存在指定的类，配置生效
@ConditionalOnMissingClass：当Classpath里不存在指定的类，配置生效
@ConditionalOnExpression：当给定的SpEL表达式计算结果为true，配置生效
@ConditionalOnProperty：当指定的配置属性有一个明确的值并匹配，配置生效

@Configuration
public class ConditionalConfig {

    /**
     * 当AppConfig对象存在时，创建一个A对象
     * @return
     */
    @ConditionalOnBean(AppConfig.class)
    @Bean
    public A createA(){
        return new A();
    }

    /**
     * 当AppConfig对象不存在时，创建一个B对象
     * @return
     */
    @ConditionalOnMissingBean(AppConfig.class)
    @Bean
    public B createB(){
        return new B();
    }


    /**
     * 当KafkaTemplate类存在时，创建一个C对象
     * @return
     */
    @ConditionalOnClass(KafkaTemplate.class)
    @Bean
    public C createC(){
        return new C();
    }

    /**
     * 当KafkaTemplate类不存在时，创建一个D对象
     * @return
     */
    @ConditionalOnMissingClass(KafkaTemplate.class)
    @Bean
    public D createD(){
        return new D();
    }


    /**
     * 当enableConfig的配置为true，创建一个E对象
     * @return
     */
    @ConditionalOnExpression("${enableConfig:false}")
    @Bean
    public E createE(){
        return new E();
    }


    /**
     * 当filter.loginFilter的配置为true，创建一个F对象
     * @return
     */
    @ConditionalOnProperty(prefix = "filter",name = "loginFilter",havingValue = "true")
    @Bean
    public F createF(){
        return new F();
    }
}

1.9 @value

可以在任意 Spring 管理的 Bean 中通过这个注解获取任何来源配置的属性值，比如你在application.properties文件里，定义了一个参数变量！

config.name=zhangsan

在任意的bean容器里面，可以通过@Value注解注入参数，获取参数变量值。

@RestController
public class HelloController {

    @Value("${config.name}")
    private String config;

    @GetMapping("config")
    public String config(){
        return JSON.toJSONString(config);
    }
}

1.10 @ConfigurationProperties

上面的@Value在每个类中获取属性配置值的做法，其实是不推荐的。一般在企业级项目开发中，不会使用那么杂乱无章的写法而且维护也麻烦，通常会一次性读取一个 Java 配置类，然后在需要使用的地方直接引用这个类就可以多次访问了，方便维护。

@ConfigurationProperties 和 @value 有着相同的功能，但是 @ConfigurationProperties的写法更为方便；
@ConfigurationProperties 的 POJO类的命名比较严格,因为它必须和prefix的后缀名要一致, 不然值会绑定不上, 特殊的后缀名是“driver-class-name”这种带横杠的情况，在POJO里面的命名规则是 “下划线转驼峰”, 就可以绑定成功，所以就是 “driverClassName”。

首先，在application.properties文件里定义好参数变量。

config.name=demo_1
config.value=demo_value_1

然后，创建一个 Java 配置类，将参数变量注入即可！

@Component
@ConfigurationProperties(prefix = "config")
public class Config {

    public String name;

    public String value;

    //...get、set
}

最后，在需要使用的地方，通过ioc注入Config对象即可！

1.11 @PropertySource

@PropertySource注解用于指定资源文件读取的位置，它不仅能读取properties文件，也能读取xml文件，并且通过YAML解析器，配合自定义PropertySourceFactory实现解析YAML文件。此注解在spring4.3之前与spring4.3及之后使用的方式不一样。

// 引入单个properties文件
@PropertySource(value = {"classpath:xxxx/xxxx.properties"})

// 引入多个properties文件
@PropertySource(value = {"classpath:xxxx/xxxx.properties","classpath:xxxx/xxxx.properties"})

spring4.3之前

spring4.3之前，除了使用@PropertySource注解之外，还要手动注册一个资源文件解析器PropertySourcesPlaceholderConfigurer到IOC容器中。并且如果使用Bean注解注册资源文件解析器，方法要是static方法。

@Configuration
@ComponentScan(basePackages = "propertysourcedemo")
@PropertySource(value = "classpath:daoconfig/datasource-config.properties")
public class SpringConfig {

    //通过SPEL表达式注入属性
    @Value("${druid.driverClassName}")
    private String driverClassName;

    @Value("${druid.url}")
    private String url;

    @Value("${druid.username}")
    private String username;

    @Value("${druid.password}")
    private String password;

    //创建资源文件解析器，spring4.3之前必须要的，不要就无法解析。
    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer(){
        return new PropertySourcesPlaceholderConfigurer();
    }

    //注册Druid数据源连接池
    @Bean
    public DruidDataSource druidDataSource(){
        System.out.println("driverClassName====> " + driverClassName);
        System.out.println("url====> " + url);
        System.out.println("username====> " + username);
        System.out.println("username====> " + username);
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

202211914451301

如果把资源解析器去掉，则没有效果。

202211914451311

spring4.3及之后

4.3之后，就可以直接使用，这时候spring会使用默认的DefaultPropertySourceFactory解析。

@Configuration
@ComponentScan(basePackages = "propertysourcedemo")
//这次使用file协议的url路径来解析
@PropertySource(value = "file:///D:/spring-high-level-study/src/main/resources/daoconfig/datasource-config.properties")
public class SpringConfig {

    //通过SPEL表达式注入属性
    @Value("${druid.driverClassName}")
    private String driverClassName;

    @Value("${druid.url}")
    private String url;

    @Value("${druid.username}")
    private String username;

    @Value("${druid.password}")
    private String password;

    //注册Druid数据源连接池
    @Bean
    public DruidDataSource druidDataSource(){
        System.out.println("driverClassName====> " + driverClassName);
        System.out.println("url====> " + url);
        System.out.println("username====> " + username);
        System.out.println("username====> " + username);
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

把配置类的@PropertySource注解路径修改成xml文件，也可以解析。

多个配置文件的示例：

@SpringBootApplication
@ComponentScan(basePackages = {"com.aron"})//通过扫描本路径可不需将ctl包和启动类放在同一目录下
@PropertySource(value= {"classpath:redis.properties","classpath:database.properties"}
                , name="ss"
                , encoding="utf-8"
                ,ignoreResourceNotFound=true)
public class ProjectMainEntranceApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ProjectMainEntranceApplication.class, args);
    }
}

1.12 @PropertySources

持有多个 PropertySource 配置，可动态增加、删除、修改所持有的 PropertySource 配置的数量及配置。@PropertySources 注解源码如下：

public @interface PropertySources {
    PropertySource[] value();
}

可以看到其实就是PropertySource的数组，因此通过@PropertySources 配置方式为：

@SpringBootApplication
@ComponentScan(basePackages = { "com.aron" }) // 通过扫描本路径可不需将ctl包和启动类放在同一目录下
@PropertySources({ @PropertySource("classpath:redis.properties"), 
                   @PropertySource("classpath:database.properties") })
public class ProjectMainEntranceApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ProjectMainEntranceApplication.class, args);
    }
}

1.13 @ImportResource

用来加载 xml 配置文件，比如导入自定义的aaa.xml文件，可以分为两种模式，相对路径的classpath，绝对路径的file。用法如下：

@Configuration相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类，再使用@ImportResource注解加载xml配置文件。

@ImportResource(locations = "classpath:aaa.xml")
@SpringBootApplication
public class PropertyApplication {

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

1.14 @Import

功能类似XML配置的，用来导入配置类，可以导入带有@Configuration注解的配置类或实现了ImportSelector/ImportBeanDefinitionRegistrar。

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

1.15 其他配置注解

@EnableAspectConfiguration：启动AspectJ自动配置。
@EnableLoadTimeWeaving：启动类加载器动态增强功能，使用instrumentation实现。
@AutoConfigurationPackage：包含该注解的package会被AutoConfigurationPackages注册。
@AutoConfigureBefore：在指定配置类初始化前加载。
@AutoConfigureAfter：在指定配置类初始化后加载。
@AutoConfigureOrder：指定配置类初始化顺序，越小初始化越早。

2、SpringMVC相关注解

2.1 @Controller

定义控制器类，通常用于修饰controller层的组件，由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），通常还需要配合注解@RequestMapping使用。需要返回页面时请用@Controller而不是@RestController；

下例中的DemoController类上如果没有 @RequestMapping(“/demoInfo”)，访问路径为项目根路径。

@Controller
@RequestMapping(“/demoInfo”)
publicclass DemoController {
    @Autowired
    private DemoInfoService demoInfoService;

    @RequestMapping("/hello")
    public String hello(Map map){
        System.out.println("DemoController.hello()");
        map.put("hello","from TemplateController.helloHtml");
        // 会使用hello.html或者hello.ftl模板进行渲染显示.
        return"/hello";
    }
}

2.2 @RequestMapping

RequestMapping是一个用来处理请求地址映射的注解，提供路由信息，负责URL到Controller中具体函数的映射，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。用于方法上时，可以指定请求协议，比如GET、POST、PUT、DELETE等等。

该注解有六个属性：

params:指定request中必须包含某些参数值是，才让该方法处理。
headers:指定request中必须包含某些指定的header值，才能让该方法处理请求。
value:指定请求的实际地址，指定的地址可以是URI Template 模式
method:指定请求的method类型， GET、POST、PUT、DELETE等
consumes:指定处理请求的提交内容类型（Content-Type），如application/json,text/html;
produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回

2.3 @RequestBody

表示请求体的Content-Type必须为application/json格式的数据，接收到数据之后会自动将数据绑定到Java对象上去。参数前加上这个注解之后，认为该参数必填。

该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上。
一个请求最多只能有一个@RequestBody注解。
Content-type = application/x-www-form-urlencoded 时 @RequestBody不是必须加的。
Content-type = mutipart/form-data 时 @RequestBody不能处理这种格式
Content-type = application/json 或 application/xml时，必须使用@RequestBody来处理

使用@RequestBody的情况：

参数是放在请求体中，当请求content_type为application/json类型的请求，数据类型为json时， json格式如下：

不使用@RequestBody的情况：

接收URL中的数据并组装为对象，当请求content_type为：application/x-www-form-urlencoded类型的或multipart/form-data时，数据格式为aaa=111&bbb=222

@Controller
@RequestMapping(“/demoInfo”)
publicclass DemoController {

    @RequestMapping("/hello")
    public String hello(@RequestBody User user){
      // 略
    }
}

2.4 @ResponseBody

表示该方法的返回结果直接写入HTTP response body中，返回数据的格式为application/json。比如，请求参数为json格式，返回参数也为json格式，示例代码如下：

一般在异步获取数据时使用，用于构建RESTful的api。
在使用@RequestMapping后，返回值通常解析为跳转路径，加上@ResponseBody后返回结果不会被解析为跳转路径，而是直接写入HTTP Response Body中。比如异步获取json数据，加上@responsebody后，会直接返回json数据。

/**
 * 登录服务
 */
@Controller
@RequestMapping("api")
public class LoginController {

    /**
     * 登录请求，post请求协议，请求参数数据格式为json
     * @param request
     */
    @RequestMapping(value = "login", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity login(@RequestBody UserLoginDTO request){
        //...业务处理
        return new ResponseEntity(HttpStatus.OK);
    }
}

2.5 @RestController

该注解是和@Controller一样，用于标注控制层组件，是@Controller和@ResponseBody的合集，表示这是个控制器Bean，并且是将函数的返回值直接填入HTTP响应体中,是REST风格的控制器。也就是说，当@RestController用在类上时，表示当前类里面所有对外暴露的接口方法，返回数据的格式都为application/json（这时候方法上不需要再加@ResponseBody注解），示范代码如下：

@RestController
@RequestMapping("api")
public class LoginController {

    /**
     * 登录请求，post请求协议，请求参数数据格式为json
     * @param request
     */
    @RequestMapping(value = "login", method = RequestMethod.POST)
    public ResponseEntity login(@RequestBody UserLoginDTO request){
        //...业务处理
        return new ResponseEntity(HttpStatus.OK);
    }
}

2.6 @RequestParam

用于接收请求参数为表单类型的数据，通常用在方法的参数前面，相当于 request.getParameter()。示范代码如下：

/**
 * 登录请求，post请求协议，请求参数数据格式为表单
 */
@RequestMapping(value = "login", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity login(@RequestParam(value = "userName",required = true) String userName,
                            @RequestParam(value = "userPwd",required = true) String userPwd){
    //...业务处理
    return new ResponseEntity(HttpStatus.OK);
}

2.7 @PathVariable

用于获取请求路径中的参数，通常用于restful风格的api上，示范代码如下：

参数与映射路径大括号里的名字相同的话，注解后括号里的内容可以不填。

/**
 * restful风格的参数请求
 * @param id
 */
@RequestMapping(value = "queryProduct/{id1}", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity queryProduct(@PathVariable("id1") String id){
    //...业务处理
    return new ResponseEntity(HttpStatus.OK);
}

/**
 * restful风格的参数请求
 * @param id
 */
@RequestMapping(value = "queryProduct/{id}", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity queryProduct(@PathVariable String id){
    //...业务处理
    return new ResponseEntity(HttpStatus.OK);
}

2.8 @GetMapping

除了@RequestMapping可以指定请求方式之外，还有一些其他的注解，可以用于标注接口路径请求，比如GetMapping用在方法上时，表示只支持get请求方法，等价于@RequestMapping(value=“/get”,method=RequestMethod.GET)。

@GetMapping("get")
public ResponseEntity get(){
    return new ResponseEntity(HttpStatus.OK);
}

2.9 @PostMapping

用在方法上，表示只支持post方式的请求，等价于@RequestMapping(value=“/post”,method=RequestMethod.POST)。

@PostMapping("post")
public ResponseEntity post(){
    return new ResponseEntity(HttpStatus.OK);
}

2.10 @PutMapping

用在方法上，表示只支持put方式的请求，通常表示更新某些资源的意思。

@PutMapping("put")
public ResponseEntity put(){
    return new ResponseEntity(HttpStatus.OK);
}

2.11 @DeleteMapping

用在方法上，表示只支持delete方式的请求，通常表示删除某些资源的意思。

@DeleteMapping("delete")
public ResponseEntity delete(){
    return new ResponseEntity(HttpStatus.OK);
}

3、Bean相关注解

3.1 @Service

通常用于修饰service层的组件（用于标注业务层组件），声明一个对象，会将类对象实例化并注入到bean容器里面。

@Service
public class DeptService {
    //具体的方法
}

3.2 @Component

泛指组件，当组件不好归类的时候，可以使用这个注解进行标注，功能类似于@Service。

@Component
public class DeptService {

    //具体的方法
}

3.3 @Repository

通常用于修饰dao层的组件，使用@Repository注解可以将数据访问层 (DAO层 ) 的类标识为Spring Bean，并确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

@Repository
public interface RoleRepository extends JpaRepository<Role,Long> {

    //具体的方法
}

为什么现在使用的很少呢？

主要是因为当我们配置服务启动自动扫描dao层包时，Spring会自动帮我们创建一个实现类，然后注入到bean容器里面。当某些类无法被扫描到时，我们可以显式的在数据持久类上标注@Repository注解，Spring会自动帮我们声明对象。

3.4 @NoRepositoryBean

一般用作父类的repository，有这个注解，spring不会去实例化该repository。

3.5 @Autowired

自动导入依赖的bean对象，默认时按照byType方式导入对象，而且导入的对象必须存在，当需要导入的对象并不存在时，我们可以通过配置required = false来关闭强制验证。

默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。
当加上（required=false）时，就算找不到bean也不报错。

@Autowired
private DeptService deptService;

3.6 @Qualifier

当有多个同一类型的bean时，使用@Autowired导入会报错，提示当前对象并不是唯一，Spring不知道导入哪个依赖，这个时候，我们可以使用@Qualifier进行更细粒度的控制，选择其中一个候选者，一般与@Autowired搭配使用。

@Autowired
@Qualifier("deptService")
private DeptService deptService;

3.7 @Resource

也是自动导入依赖的bean对象，由JDK提供，默认是按照byName方式导入依赖的对象；而@Autowired默认时按照byType方式导入对象，当然@Resource还可以配置成通过byType方式导入对象。

/**
 * 默认通过名称导入
 */
@Resource
private DeptService deptService;


/**
 * 通过名称导入（默认通过名称导入依赖对象）
 */
@Resource(name = "deptService")
private DeptService deptService;

/**
 * 通过类型导入
 */
@Resource(type = RoleRepository.class)
private DeptService deptService;

/**
 * 通过名称和类型导入
 */
@Resource(name = "deptService", type = RoleRepository.class)
private DeptService deptService;

3.8 @Scope

用于声明一个spring bean的作用域，作用的范围一共有以下几种：

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

Spring 的Controller 实例化默认是单例，是线程不安全的，并发时可能会导致变量值不准. @Scope(“prototype”)注可以让单例变成多例。

/**
 * 多例对象
 */
@RestController
@Scope("prototype")
public class HelloController {

}

4、JPA相关注解

4.1 @Entity和@Table

表明这是一个实体类，这两个注解一般一块使用，如果表名和实体类名相同的话，@Table可以省略。

4.2 @Id

表示该属性字段对应数据库表中的主键字段。

4.3 @Column

表示该属性字段对应的数据库表中的列名，如果字段名与列名相同，则可以省略。

4.4 @GeneratedValue

表示主键的生成策略，有四个选项，分别如下：

AUTO：表示由程序控制，是默认选项，不设置就是这个
IDENTITY：表示由数据库生成，采用数据库自增长，Oracle 不支持这种方式
SEQUENCE：表示通过数据库的序列生成主键ID，MYSQL 不支持
Table：表示由特定的数据库产生主键，该方式有利于数据库的移植

@GeneratedValue(strategy=GenerationType.SEQUENCE,generator= “repair_seq”)：表示主键生成策略是sequence（可以为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。

4.5 @SequenceGeneretor

用来定义一个生成主键的序列，它需要与@GeneratedValue联合使用才有效，以TB_ROLE表为例，对应的注解配置如下：

@SequenceGenerator(name = “id_seq”, sequenceName = “seq_repair”,allocationSize = 1)中，name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称可以一致。

@Entity
@Table(name = "TB_ROLE")
@SequenceGenerator(name = "id_seq", sequenceName = "seq_repair",allocationSize = 1)
public class Role implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键ID，采用【id_seq】序列函数自增长
     */
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "id_seq")
    private Long id;


    /* 角色名称
     */
    @Column(nullable = false)
    private String roleName;

    /**
     * 角色类型
     */
    @Column(nullable = false)
    private String roleType;
}

4.6 @Transient

表示该属性并非与数据库表的字段进行映射，ORM 框架会将忽略该属性。如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则ORM框架默认其注解为@Basic。

/**
 * 忽略该属性
 */
@Transient
private String lastTime;

4.7 @JsonIgnore

作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。即在实体类向前台返回数据时用来忽略不想传递给前台的属性或接口。如Bean实体中会有某些运维字段，返回信息给前台的时候，不希望将对应值一并返回。此时可以在对应属性上加上@JsonIgnore，或者可以在User类上加上注解 @JsonIgnoreProperties(value=“{password}”)

4.8 @Basic

@Basic(fetch=FetchType.LAZY)用在某些属性上，可以实现懒加载的效果，也就是当用到这个字段的时候，才会装载这个属性，如果配置成fetch=FetchType.EAGER，表示即时加载，也是默认的加载方式！

/**
 * 延迟加载该属性
 */
@Column(nullable = false)
@Basic(fetch = FetchType.LAZY)
private String roleType;

4.9 @JoinColumn

用于标注表与表之间关系的字段，通常与@OneToOne、@OneToMany搭配使用，例如如下

@Entity
@Table(name = "tb_login_log")
public class LoginLog implements Serializable {

    /**
     * 查询登录的用户信息
     */
    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;

    //...get、set
}

4.10 @OneToOne、@OneToMany和@ManyToOne

这三个注解，相当于hibernate配置文件中的一对一，一对多，多对一配置，比如下面的客户地址表，通过客户 ID，实现客户信息的查询。

@Entity
@Table(name="address")
public class AddressEO implements java.io.Serializable {

  @ManyToOne(cascade = { CascadeType.ALL })
  @JoinColumn(name="customer_id")
  private CustomerEO customer;

  //...get、set
}

5、异常处理相关注解

5.1 @ControllerAdvice和@ExceptionHandler

通常组合使用，用于处理全局异常，@ControllerAdvice包含@Component。@ExceptionHandler（Exception.class）用在方法上面表示遇到这个异常就执行以下方法。示例代码如下：

@ControllerAdvice
@Configuration
@Slf4j
public class GlobalExceptionConfig {

    private static final Integer GLOBAL_ERROR_CODE = 500;

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public void exceptionHandler(HttpServletRequest request, HttpServletResponse response, Exception e) throws Exception {
        log.error("【统一异常处理器】", e);
        ResultMsg<Object> resultMsg = new ResultMsg<>();
        resultMsg.setCode(GLOBAL_ERROR_CODE);
        if (e instanceof CommonException) {
            CommonException ex = (CommonException) e;
            if(ex.getErrCode() != 0) {
                resultMsg.setCode(ex.getErrCode());
            }
            resultMsg.setMsg(ex.getErrMsg());
        }else {
            resultMsg.setMsg(CommonErrorMsg.SYSTEM_ERROR.getMessage());
        }
        WebUtil.buildPrintWriter(response, resultMsg);
    }
}

6、测试相关注解

6.1 @ActiveProfiles

一般作用于测试类上，用于声明生效的 Spring 配置文件，比如指定application-dev.properties配置文件。

6.2 @RunWith和@SpringBootTest

一般作用于测试类上，用于单元测试用，示例如下：

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestJunit {

    @Test
    public void executeTask() {
        //测试...
    }
}

7、springcloud注解

7.1 @EnableEurekaServer

用在springboot启动类上，表示这是一个eureka服务注册中心。

7.2 @EnableDiscoveryClient

用在springboot启动类上，表示这是一个服务，可以被注册中心找到。

7.3 @LoadBalanced

开启负载均衡能力。

7.4 @EnableCircuitBreaker

用在启动类上，开启断路器功能。

7.5 @HystrixCommand

@HystrixCommand(fallbackMethod=”backMethod”)用在方法上，fallbackMethod指定断路回调方法。

7.6 @EnableConfigServer

用在启动类上，表示这是一个配置中心，开启Config Server。

7.7 @EnableZuulProxy

开启zuul路由，用在启动类上。

7.8 @SpringCloudApplication

@SpringCloudApplication包含@SpringBootApplication、@EnableDiscovertyClient、@EnableCircuitBreaker，分别是SpringBoot注解、注册服务中心Eureka注解、断路器注解。对于SpringCloud来说，这是每一个微服务必须应有的三个注解，所以才推出了@SpringCloudApplication这一注解集合。

8、其他注解

8.1 缓存

@EnableCaching，开启缓存配置，支持子类代理或者AspectJ增强
@CacheConfig，在一个类下，提供公共缓存配置
@Cacheable，放着方法和类上，缓存方法或类下所有方法的返回值
@CachePut，每次先执行方法，再将结果放入缓存
@CacheEvict，删除缓存
@Caching，可以配置@Cacheable、@CachePut、@CacheEvict

8.2 定时器

@EnableScheduling，开启定时任务功能
@Scheduled，按指定执行周期执行方法
@Schedules，包含多个@Scheduled，可同时运行多个周期配置
@EnableAsync，开启方法异步执行的能力，通过@Async或者自定义注解找到需要异步执行的方法。通过实现AsyncConfigurer接口的getAsyncExecutor()和getAsyncUncaughtExceptionHandler()方法自定义Executor和异常处理。
@Async，标记方法为异步线程中执行

SpringBoot常用注解详解