springboot注解大全
SpringBoot注解就是给代码打上标签的能力。通过引入注解，我们可以简单快速赋予代码生命力，大大提高代码可读性和扩展性。注解本身不具有任何能力，只是一个标签，但是我们可以定义各种标签然后实现各种标签处理器来对类、方法、属性甚至参数等进行功能扩展、功能开启、属性定义、行为定义、规则定义、关联处理、元数据定义等等。
元注解
@Documented：将会在被此注解注解的元素的javadoc文档中列出注解，一般都打上这个注解没坏处
@Target：注解能被应用的目标元素，比如类、方法、属性、参数等等，需要仔细思考
@Retention：仅在源码保留，还是保留到编译后的字节码，还是到运行时也去加载，超过90%的应用会在运行时去解析注解进行额外的处理，所以大部分情况我们都会设置配置为RetentionPolicy.RUNTIME
@Inherited：如果子类没有定义注解的话，能自动从父类获取定义了继承属性的注解，比如Spring的@Service是没有继承特性的，但是@Transactional是有继承特性的，在OO继承体系中使用Spring注解的时候请特别注意这点，理所当然认为注解是能被子类继承的话可能会引起不必要的Bug，需要仔细斟酌是否开启继承
@Repeatable：Java 8引入的特性，通过关联注解容器定义可重复注解，小小语法糖提高了代码可读性，对于元素有多个重复注解其实是很常见的事情，比如某方法可以是A角色可以访问也可以是B角色可以访问，某方法需要定时任务执行，要在A条件执行也需要在B条件执行
@Native：是否在.h头文件中生成被标记的字段，除非原生程序需要和Java程序交互，否则很少会用到这个元注解
基本注解
@Service: 注解在类上，表示这是一个业务层bean
@Controller：注解在类上，表示这是一个控制层bean
@Repository: 注解在类上，表示这是一个数据访问层bean
@Component： 注解在类上，表示通用bean ，value不写默认就是类名首字母小写
@Autowired：按类型注入.默认属性required= true
@Resource: 按名称装配。
启动注解
@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中
@ComponentScan：让spring Boot扫描到Configuration类并把它加入到程序上下文。
@SpringBootConfiguration ：等同于spring的XML配置文件；使用Java代码可以检查类型安全。
@EnableAutoConfiguration ：自动配置。
HTTP注解
@RequestBody：HTTP请求获取请求体（处理复杂数据，比如JSON）
@RequestHeader：HTTP请求获取请求头
@CookieValue：HTTP请求获取cookie
@SessionAttribute：HTTP请求获取会话
@RequestAttribute：HTTP请求获取请求的Attribute中（比如过滤器和拦截器手动设置的一些临时数据），
@RequestParam：HTTP请求获取请求参数（处理简单数据，键值对），
@PathVariable：HTTP请求获取路径片段，
@MatrixAttribute：HTTP请求获取矩阵变量允许我们采用特殊的规则在URL路径后加参数（分号区分不同参数，逗号为参数增加多个值）
其他注解
@Transient：表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。
@ConfigurationProperties：给对象赋值，将注解转换成对象。
@RequestMapping：和请求报文是做对应的
@EnableCaching：注解驱动的缓存管理功能
@GeneratedValue：用于标注主键的生成策略，通过 strategy 属性指定
@JsonIgnore：作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
@JoinColumn（name=”loginId”）:一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。
----------------------------------------------------------
Spring注解
在Spring Core注解中，主要讨论Spring DI和Spring IOC中使用的Spring核心注释。众所周知，Spring DI和Spring IOC是Spring框架的核心概念。所以介绍org.springframework.beans.factory.annotation 和org.springframework.context.annotation 包中的注解。这两个包中注解有很多，就抽取其中的15个注解。
Spring Core Annotations:
@Autowired
@Qualifier
@Bean
@Required
@Value
@DependsOn
@Lazy
@Lookup
@Primary
@Scope
@Profile
@Import
@ImportResource
@PropertySource
@PropertySources
单单 org.springframework.context.annotation 这个包下面，注解就有这老些，所以很难列出所有注解举例，只能抽一些常用的。文末会给出其它注解的作用和定义(尽量给全)。
1.1 @Autowired
@Autowired是一种注解，可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作，@Autowired标注可以放在成员变量上，也可以放在成员变量的set方法上，也可以放在任意方法上表示，自动执行当前方法，如果方法有参数，会在IOC容器中自动寻找同类型参数为其传值。
这里必须明确：@Autowired是根据类型进行自动装配的，如果需要按名称进行装配，则需要配合@Qualifier使用；
1.1.1 构造器注入
@RestController
public class UserController {
private UserService userService;
@Autowired
public UserController(UserService userService) {
this.userService = userService;
}
}
1.1.2 setter方法注入
@RestController
public class UserController {
private UserService userService;
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
}
1.1.3 field反射注入
@RestController
public class UserController {
@Autowired
private UserService userService;
}
1.2 @Qualifier
上面已经说到@Autowired按类型装配Spring Bean。如果容器中有多个相同类型的bean，则框架将抛出NoUniqueBeanDefinitionException， 以提示有多个满足条件的bean进行自动装配。程序无法正确做出判断使用哪一个，通过将@Qualifier注解与我们想要使用的特定Spring bean的名称一起进行装配，Spring框架就能从多个相同类型并满足装配要求的bean中找到我们想要的，
@Component("studentInfo")
public class StudentInfo implements UserInfo {
public String userName() {
return "student";
}
}
@Component("teacherInfo")
public class TeacherInfo implements UserInfo {
public String userName {
return "teacher";
}
}
@Component
public class UserService {
@Autowired
@Qualifier("studentInfo")
private UserInfo userInfo;
//todo
}
1.3 @Bean
@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。添加的bean的id为方法名。
@Configuration
public class BeanConfig {
@Bean
public Person userInfo() {
return new UserInfo("toutou", 18);
}
}
这个配置就等同于之前在xml里的配置：
<bean id="userInfo" class="com.test.UserInfo">
<property name="age" value="18"/>
<property name="name" value="请叫我头头哥 http://toutou.cnblogs.com"/>
bean>
1.4 @Required
@Required 注释应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个 BeanInitializationException 异常。
@Required
void setUserName(String name) {
this.name = name;
}
<bean class="com.test.UserInfo">
<property name="name" value="请叫我头头哥 https://www.cnblogs.com/toutou/" />
bean>
1.5 @Value
@Value将外部的值动态注入到Bean中。"注入外部的值"可以有很多种，它可以注入普通字符串、注入java 系统变量、注入表达式结果、注入其他Bean属性、将配置文件 *.properties 或 *. yml 李 配置的 属性 注入、注入文件资源和注入url资源等。
1.6 @DependsOn
Spring容器载入bean顺序是不确定的，Spring框架也没有约定特定载入顺序逻辑规范。@DependsOn注解可以定义在类和方法上，比如说A组件要依赖于B组件，那就是B组件需要比A组件先注册到IOC容器中。
public class FirstBean {
@Autowired
private SecondBean secondBean;
}
public class SecondBean {
public SecondBean() {
System.out.println("SecondBean init");
}
}
@Configuration
public class BeanConfig {
@Bean("firstBean")
@DependsOn(value = {
"secondBean"
})
public FirstBean firstBean() {
return new FirstBean();
}
@Bean("secondBean")
public SecondBean secondBean() {
return new SecondBean();
}
}
1.7 @Lazy
@Lazy注解用于标识bean是否需要延迟加载。Spring IoC容器一般都会在启动的时候实例化所有单实例bean，如果想要Spring在启动的时候延迟加载A，即在调用B的时候再去初始化，则可以使用@Lazy注解。
public class FirstBean {
public void test() {
System.out.println("FirstBean Class");
}
}
public class SecondBean {
public void test() {
System.out.println("SecondBean Class");
}
}
@Configuration
public class AppConfig {
@Lazy(value = true)
@Bean
public FirstBean firstBean() {
return new FirstBean();
}
@Bean
public SecondBean secondBean() {
return new SecondBean();
}
}
1.8 @Lookup
@Lookup的注解是一个作用在方法上的注解，被其标注的方法会被重写，然后根据其返回值的类型，容器调用BeanFactory的getBean()方法来返回一个bean。
1.9 @Primary
@Primary与@Qualifier类似，都是解决@Autowired时容器中有多个相同类型bean的问题，Primary可以理解为默认优先选择,同时不可以同时设置多个。
@Component("studentInfo")
public class StudentInfo implements UserInfo {
public String userName() {
return "student";
}
}
@Component("teacherInfo")
@Primary
public class TeacherInfo implements UserInfo {
public String userName {
return "teacher";
}
}
@Component
public class UserService {
@Autowired
@Qualifier("studentInfo")
private UserInfo userInfo;
//todo
}
1.10 @Scope
@Scope注解是springIoc容器中的一个作用域，在 Spring IoC 容器中具有以下几种作用域：基本作用域singleton（单例）(默认作用域)、prototype(多例)，Web 作用域（reqeust、session、globalsession），自定义作用域
1.11 @Profile
@profile注解的作用是为了应对多环境开发，比如开发环境使用dev, 生产环境使用prod,就可以使用@Profile注解实现不同的开发环境使用不同的数据源。spring3.2之前 @Profile注解用在类上，spring3.2 之后 @Profile注解用在方法上
1.12 @Import
@Import用于注入指定的类，导入组件id默认是组件的全类名。
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}
1.13 @ImportResource
@ImportResource注解用于导入Spring的配置文件，让配置文件里面的内容生效；(就是以前写的springmvc.xml、applicationContext.xml)
@Configuration
@ImportResource({"classpath*:applicationContext.xml"})
public class XmlConfiguration {
}
1.14 @PropertySource
@PropertySource注解加载指定的配置文件
@Configuration
@PropertySource("classpath:config.properties")
public class ProperySourceDemo implements InitializingBean {
@Autowired
Environment env;
@Override
public void afterPropertiesSet() throws Exception {
setDatabaseConfig();
}
private void setDatabaseConfig() {
DataSourceConfig config = new DataSourceConfig();
config.setDriver(env.getProperty("jdbc.driver"));
config.setUrl(env.getProperty("jdbc.url"));
config.setUsername(env.getProperty("jdbc.username"));
config.setPassword(env.getProperty("jdbc.password"));
System.out.println(config.toString());
}
}
1.15 @PropertySources
@PropertySources顾名思义就是可以指定多个@PropertySource来导入配置文件。
@PropertySources({
@PropertySource("classpath:config.properties"),
@PropertySource("classpath:db.properties")
})
public class AppConfig {
//todo...
}
SpringWeb注解
2.1 @RequestBody
主要用来接收前端传递给后端的json字符串中的数据的。
@RestController
@RequestMapping("/api/v1")
public class UserController {
@Autowired
private UserService userService;
@PostMapping("/user")
public UserInfo createUser(@Valid @RequestBody UserInfo user) {
return userService.save(user);
}
}
2.2 @RequestMapping
@RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。也就是通过它来指定控制器可以处理哪些URL请求。
@Controller
class UserController {
@RequestMapping(value = "/user/index", method = RequestMethod.GET)
String index() {
return "index";
}
}
2.3 @GetMapping
@GetMapping注释将Http GET请求映射到特定的处理程序方法。 它是一个组合的注释，@RequestMapping(method = RequestMethod.GET)的快捷方式。
@GetMapping("/users")
public List
2.4 @PathVariable
@PathVariable是spring3.0的一个新功能：接收请求路径中占位符的值
2.5 @PostMapping
@PostMapping注释将HTTP POST请求映射到特定的处理程序方法。 它是一个组合的注释，@RequestMapping(method = RequestMethod.POST)的快捷方式。
@PostMapping("/user/add")
public User addUser(@Valid @RequestBody User user) {
return userRepository.save(user);
}
其它扩展: @PutMapping、@DeleteMapping、@PatchMapping(这三种相对用的比较少，一笔带过。)
2.6 @ControllerAdvice
增强型控制器，对于控制器的全局配置放在同一个位置。可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，可处理全局异常处理、全局数据绑定和全局数据预处理。
@ControllerAdvice(basePackages = {"com.toutou.controller"} )
public class GlobalControllerAdvice {
@InitBinder
public void dataBinding(WebDataBinder binder) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, "dob", new CustomDateEditor(dateFormat, true));
}
@ModelAttribute
public void globalAttributes(Model model) {
model.addAttribute("msg", "Hello World!");
}
@ExceptionHandler(FileNotFoundException.class)
public ModelAndView myError(Exception exception) {
ModelAndView mav = new ModelAndView();
mav.addObject("exception", exception);
mav.setViewName("error");
return mav;
}
}
2.7 @ExceptionHandler
@ExceptionHandler统一处理某一类异常，从而能够减少代码重复率和复杂度。
2.8 @InitBinder
@InitBinder只在@Controller中注解方法来为这个控制器注册一个绑定器初始化方法，方法只对本控制器有效。
2.9 @ModelAttribute
@ModelAttribute注解用于将方法的参数或方法的返回值绑定到指定的模型属性上，并返回给Web视图。
2.10 @ResponseBody
@ResponseBody将controller里方法返回的对象通过适当的转换器转换为Json写入到response对象的body区.
2.11 @Controller
@Controller用于标记在一个类上，使用它标记的类就是一个SpringMvc Controller对象，分发处理器会扫描使用该注解的类的方法，并检测该方法是否使用了@RequestMapping注解。
2.12 @RestController
@RestController在Spring中的作用等同于@Controller + @ResponseBody。
2.13 @RequestParam
@RequestParam将请求参数绑定到你控制器的方法参数上（是springmvc中接收普通参数的注解）
2.14 @CrossOrigin
@CrossOrigin支持跨域，可用于Controller上，也可用于方法上。
@CrossOrigin(origins = "http://toutou.com", maxAge = 3600)
@RequestMapping("/index")
String index() {
return "Hello World!";
}
SpringBoot注解
3.1 @SpringBootApplication
@SpringBootApplication是Sprnig Boot项目的核心注解，目的是开启自动配置。由于@Configuration,@EnableAutoConfiguration和@ComponentScan三个注解一般都是一起使用，于是spring boot提供了一个统一的注解@SpringBootApplication。即：@SpringBootApplication=@Configuration + @EnableAutoConfiguration + @ComponentScan。
@SpringBootApplication // 等于：@Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
如上代码，是不是简洁了不少。
3.2 @EnableAutoConfiguration
可以根据classpath中的jar依赖，自动注册bean,一般用于类或接口上,它尝试根据您添加的jar依赖项自动配置Spring应用程序。自动载入应用程序所需的所有Bean——这依赖于Spring Boot在类路径中的查找。
@EnableAutoConfiguration
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
3.3 @ConditionalOnClass、@ConditionalOnMissingClass
3.4 @ConditionalOnBean、@ConditionalOnMissingBean
@ConditionalOnBean // 当给定的在bean存在时,则实例化当前Bean
@ConditionalOnMissingBean // 当给定的在bean不存在时,则实例化当前Bean
@ConditionalOnClass // 当给定的类名在类路径上存在，则实例化当前Bean
@ConditionalOnMissingClass // 当给定的类名在类路径上不存在，则实例化当前Bean
3.5 @ConditionalOnProperty
@ConditionalOnProperty可以通过配置文件中的属性值来判定configuration是否被注入。
3.6 @ConditionalOnResource
@ConditionalOnResource是注解在Configuration bean上，在其加载之前对指定资源进行校验，是否存在，如果不存在，抛出异常；该注解支持传入多个变量，
3.7 @ConditionalOnWebApplication、@ConditionalOnNotWebApplication
@ConditionalOnWebApplication主要的用处是： 当Spring为web服务时，才使注解的类生效；通常是配置类；@ConditionalOnNotWebApplication不是web应用。
3.8 @Conditional
@Conditional的作用是按照一定的条件进行判断，满足条件给容器注册bean。
回到顶部
SpringScheduling注解
4.1 @Scheduled
@Scheduled可以作为一个触发源添加到一个方法中。
@Scheduled(fixedDelay=1000)
public void doSomething() {
//...
}
4.2 @EnableScheduling
@EnableScheduling 在配置类上使用，开启计划任务的支持（类上）。
@Configuration
@EnableScheduling //通过@EnableScheduling注解开启对计划任务的支持
public class TaskScheduleConfig {
//...
}
4.3 @Async
@Async标注的方法，称之为异步方法；这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作。有时候我们会调用一些特殊的任务，任务会比较耗时，重要的是，我们不管他返回的后果。这时候我们就需要用这类的异步任务啦。
4.4 @EnableAsync
@EnableAsync注解启用了Spring异步方法执行功能
@Schedules
@Schedules作用跟@Scheduled一样，@Schedules内部包含多个@Scheduled注解，可以表示一个方法可以存在多个调度设置。
注解集合
@ComponentScan：表示将该类自动发现扫描组件。个人理解相当于，如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。如果没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。
@Repository：使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。
@Inject：等价于默认的@Autowired，只是没有required属性；
@Component：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@JsonBackReference：解决嵌套外链问题。
@JsonIgnore：作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
@ConfigurationProperties：Spring Boot可使用注解的方式将自定义的properties文件映射到实体bean中，比如config.properties文件。
@ConditionalOnSingleCandidate：组合@Conditional注解，当指定的class在容器中只有一个Bean，或者同时有多个但为首选时才开启配置。
@ConditionalOnCloudPlatform：组合 @Conditional 注解，当指定的云平台激活时才开启配置。
@ConditionalOnJndi：组合 @Conditional 注解，当指定的 JNDI 存在时才开启配置。
@ConditionalOnJava：组合@Conditional 注解，当运行的 Java JVM 在指定的版本范围时才开启配置。
@ConditionalOnExpression：组合 @Conditional 注解，当 SpEL 表达式为 true 时才开启配置。
@WiselyConfiguration: 组合注解可以替代@Configuration和@ComponentScan
@Transcational: 事务处理
@Target (ElementType.TYPE):元注解,用来指定注解修饰类的那个成员 -->指定拦截规则
@Cacheable: 数据缓存
@ActiveProfiles: 用来声明活动的 profile
@RunWith: 运行器
-----------------------------------
1、@SpringBootApplication
一般不会主动去使用它，但是要知道它是一个组合注解，@Configuration 、@EnableAutoConfiguration 、@ComponentScan 注解的集合
2、@Configuration
用@Configuration注释类表明是一个配置类，允许在 Spring 上下文中注册额外的 bean 或导入其他配置类。
3、@EnableAutoConfiguration
该注解就是用来开启自动配置的，自动配置原理可以去看一下博主springboot系列记录中的文章
4、@ComponentScan
@ComponentScan用于类或接口上主要是指定扫描路径，spring会把指定路径下带有指定注解的类自动装配到bean容器里。会被自动装配的注解包括@Controller、 @Service、@Component、@Repository等等。其作用等同于<context:component-scan base-package="com.xxx.xxx" />配置
5、@Autowired、@Qualifier
@Autowired它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作，默认是按照类去匹配
当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用
6、@Component,@Respository,@Service,@Controller
@Component ：通用的注解，可标注任意类为 Spring组件。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。
@Repository : 对应持久层即 Dao 层，主要用于数据库相关操作。
@Service : 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。
@Controller : 对应 Spring MVC 控制层，主要用户接受用户请求并调用 Service 层返回数据给前端页面。
7、@RequestMapping
是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
该注解中的属性释义：
value： 指定请求的实际地址
method： 指定请求的method类型， GET、POST、PUT、DELETE等；
consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;
produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
params： 指定request中必须包含某些参数值是，才让该方法处理。
headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求。
8、@ResponseBody
@ResponseBody注解既可以在方法上使用，也可以在类上使用，在类上使用表明该类中所有方法均返回JSON数据，也可以与@Controller注解合并为@RestController。它的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。
9、@GetMapping @PutMapping @PostMapping @DeleteMapping
也就是对应HTTP的请求方式，
GET ：请求从服务器获取特定资源。举个例子：GET /users（获取所有学生）
POST ：在服务器上创建一个新的资源。举个例子：POST /users（创建学生）
PUT ：更新服务器上的资源（客户端提供更新后的整个资源）。举个例子：PUT /users/12（更新编号为 12 的学生）
DELETE ：从服务器删除特定的资源。举个例子：DELETE /users/12（删除编号为 12 的学生）
以@DeleteMapping为例子来看一下
@DeleteMapping("/users/{userId}")等价于@RequestMapping(value="/users/{userId}",method=RequestMethod.DELETE)
10、@PathVariable
@PathVariable就是用于获取路径参数
@RequestMapping("/getUserById/{name}")
public User getUser(@PathVariable("name") String name){
return userService.getUser(name);
}
11、@RequestParam
用于获取查询参数，
语法：@RequestParam(value=”参数名”,required=”true/false”,defaultValue=””)
value：参数名
required：是否包含该参数，默认为true，表示该请求路径中必须包含该参数，如果不包含就报错。
defaultValue：默认参数值，如果设置了该值，required=true将失效，自动为false,如果没有传该参数，就使用默认值
12、@RequestBody
不要和@ResponseBody混淆了，@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的),Content-Type 为 application/json 格式；GET方式无请求体，所以使用@RequestBody接收数据时，前端不能使用GET方式提交数据，而是用POST方式进行提交。
比如前端以post方式传json字符串，此时后端就可以使用@RequestBody来接收
13、@Value、@ConfigurationProperties
这一类注解建议看 Springboot系列记录（二）——Springboot配置文件的读取
14、@DateTimeFormat、@JsonFormat
实体类User有个Date类型的属性birthday，然后用该实体类接收从前端传来的参数，我们会发现报了400异常。
因为前端传去的是字符串类型，而实体类中是Date类型，那么此时就可以使用@DateTimeFormat
已经可以了，但是这种格式不是我们想要的，那么@JsonFormat登场了，timezone：是时间设置为东八区，避免时间在转换中有误差
可见：@DateTimeFormat是前台到后台的时间转换，而@JsonFormat是后台到前台的转换
15、@Import
@Import只能用在类上 ，@Import通过快速导入的方式实现把实例加入spring的IOC容器中
用法：
@Import({ 类名.class , 类名.class... })
————————————————
一、注解(annotations)列表
@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。
@Configuration等同于spring的XML配置文件；使用Java代码可以检查类型安全。
@EnableAutoConfiguration自动配置。
@ComponentScan组件扫描，可自动发现和装配一些Bean。
@Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。
@RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。
@Autowired自动导入。
@PathVariable获取参数。
@JsonBackReference解决嵌套外链问题。
@RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。
二、注解(annotations)详解
@SpringBootApplication：申明让spring boot自动给程序进行必要的配置，这个配置等同于：@Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三个配置。
packagecom.example.myproject;importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication// same as @Configuration @EnableAutoConfiguration @ComponentScanpublicclassApplication{publicstaticvoidmain(String[] args){SpringApplication.run(Application.class, args);}}
@ResponseBody：表示该方法的返回结果直接写入HTTP response body中，一般在异步获取数据时使用，用于构建RESTful的api。在使用@RequestMapping后，返回值通常解析为跳转路径，加上@responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如异步获取json数据，加上@responsebody后，会直接返回json数据。该注解一般会配合@RequestMapping一起使用。示例代码：
@RequestMapping(“/test”)@ResponseBodypublic String test(){return”ok”;}
@Controller：用于定义控制器类，在spring 项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。示例代码：
@Controller@RequestMapping(“/demoInfo”)publicclass DemoController {@AutowiredprivateDemoInfoService demoInfoService;@RequestMapping("/hello")publicStringhello(Map<String,Object> map){System.out.println("DemoController.hello()");map.put("hello","from TemplateController.helloHtml");//会使用hello.html或者hello.ftl模板进行渲染显示.return"/hello";}}
@RestController：用于标注控制层组件(如struts中的action)，@ResponseBody和@Controller的合集。示例代码：
packagecom.kfit.demo.web;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.RestController;@RestController@RequestMapping(“/demoInfo2”)publicclass DemoController2 {@RequestMapping("/test")public String test(){return"ok";}}
@RequestMapping：提供路由信息，负责URL到Controller中的具体函数的映射。
@EnableAutoConfiguration：Spring Boot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库”。你可以将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。
@ComponentScan：表示将该类自动发现扫描组件。个人理解相当于，如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。如果没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。
@Configuration：相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。
@Import：用来导入其他配置类。
@ImportResource：用来加载xml配置文件。
@Autowired：自动导入依赖的bean
@Service：一般用于修饰service层的组件
@Repository：使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。
@Bean：用@Bean标注方法等价于XML中配置的bean。
@Value：注入Spring boot application.properties配置的属性的值。示例代码：
@Value(value= “#{message}”)privateString message;
@Inject：等价于默认的@Autowired，只是没有required属性；
@Component：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Bean:相当于XML中的,放在方法的上面，而不是类，意思是产生一个bean,并交给spring管理。
@AutoWired：自动导入依赖的bean。byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。当加上（required=false）时，就算找不到bean也不报错。
@Qualifier：当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，具体使用方式如下：
@Autowired@Qualifier(value = “demoInfoService”)private DemoInfoService demoInfoService;
@Resource(name=”name”,type=”type”)：没有括号内内容的话，默认byName。与@Autowired干类似的事。
三、JPA注解
@Entity：@Table(name=”“)：表明这是一个实体类。一般用于jpa这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table可以省略
@MappedSuperClass:用在确定是父类的entity上。父类的属性子类可以继承。
@NoRepositoryBean:一般用作父类的repository，有这个注解，spring不会去实例化该repository。
@Column：如果字段名与列名相同，则可以省略。
@Id：表示该属性为主键。
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”)：表示主键生成策略是sequence（可以为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。
@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)：name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称可以一致。
@Transient：表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic。@Basic(fetch=FetchType.LAZY)：标记可以指定实体属性的加载方式
@JsonIgnore：作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
@JoinColumn（name=”loginId”）:一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。
@OneToOne、@OneToMany、@ManyToOne：对应hibernate配置文件中的一对一，一对多，多对一。
四、springMVC相关注解
@RequestMapping：@RequestMapping(“/path”)表示该控制器处理所有“/path”的UR L请求。RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。该注解有六个属性：params:指定request中必须包含某些参数值是，才让该方法处理。headers:指定request中必须包含某些指定的header值，才能让该方法处理请求。value:指定请求的实际地址，指定的地址可以是URI Template 模式method:指定请求的method类型， GET、POST、PUT、DELETE等consumes:指定处理请求的提交内容类型（Content-Type），如application/json,text/html;produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回
@RequestParam：用在方法的参数前面。@RequestParam String a =request.getParameter(“a”)。
@PathVariable:路径变量。如
RequestMapping(“user/get/mac/{macAddress}”)publicStringgetByMacAddress(@PathVariableString macAddress){//do something;}
参数与大括号里的名字一样要相同。
五、全局异常处理
@ControllerAdvice：包含@Component。可以被扫描到。统一处理异常。
@ControllerAdvice是@Component注解的一个延伸注解，Spring会自动扫描并检测被@ControllerAdvice所标注的类。@ControllerAdvice需要和@ExceptionHandler、@InitBinder以及@ModelAttribute注解搭配使用，主要是用来处理控制器所抛出的异常信息。
首先，我们需要定义一个被@ControllerAdvice所标注的类，在该类中，定义一个用于处理具体异常的方法，并使用@ExceptionHandler注解进行标记。
此外，在有必要的时候，可以使用@InitBinder在类中进行全局的配置，还可以使用@ModelAttribute配置与视图相关的参数。使用@ControllerAdvice注解，就可以快速的创建统一的，自定义的异常处理类。
下面是一个使用@ControllerAdvice的示例代码：
@ExceptionHandler（Exception.class）：用在方法上面表示遇到这个异常就执行以下方法。
@ExceptionHander注解用于标注处理特定类型异常类所抛出异常的方法。当控制器中的方法抛出异常时，Spring会自动捕获异常，并将捕获的异常信息传递给被@ExceptionHandler标注的方法。
@CrossOrigin
@CrossOrigin注解将为请求处理类或请求处理方法提供跨域调用支持。如果我们将此注解标注类，那么类中的所有方法都将获得支持跨域的能力。使用此注解的好处是可以微调跨域行为。使用此注解的示例如下：
4.springcloud
@EnableEurekaServer:
用在springboot启动类上，表示这是一个eureka服务注册中心；
@EnableDiscoveryClient:
用在springboot启动类上，表示这是一个服务，可以被注册中心找到；
@LoadBalanced:
开启负载均衡能力；
@EnableCircuitBreaker:
用在启动类上，开启断路器功能；
@HystrixCommand(fallbackMethod=”backMethod”):
用在方法上，fallbackMethod指定断路回调方法；
@EnableConfigServer:
用在启动类上，表示这是一个配置中心，开启Config Server；
@EnableZuulProxy:
开启zuul路由，用在启动类上；
@SpringCloudApplication:
包含
@SpringBootApplication
@EnableDiscovertyClient
@EnableCircuitBreaker
————————————————
一、注解(annotations)列表
1、@SpringBootApplication
包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。
其中@ComponentScan让Spring Boot扫描到Configuration类并把它加入到程序上下文。
2、@ComponentScan
组件扫描，可自动发现和装配一些Bean。
3、@Configuration
等同于Spring的XML配置文件；使用Java代码可以检查类型安全。
4、@EnableAutoConfiguration
自动配置
5、@RestController
该注解是@Controller和@ResponseBody的合集,表示这是个控制器Bean,并且是将函数的返回值直接填入HTTP响应体中,是REST风格的控制器。
6、@Autowired
自动导入依赖的bean。
7、@PathVariable
获取参数。
8、@JsonBackReference
解决嵌套外链问题。
9、@RepositoryRestResourcepublic
配合spring-boot-starter-data-rest使用。
10、@Scope
Spring 的Controller 实例化默认是单例，是线程不安全的，并发时可能会导致变量值不准. @Scope("prototype")注解,让单例变成多例
二、注解(annotations)详解
1、@SpringBootApplication：申明让Spring Boot自动给程序进行必要的配置，这个配置等同于：@Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三个配置。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
2、@ResponseBody：表示该方法的返回结果直接写入HTTP Response Body中，一般在异步获取数据时使用，用于构建RESTful的api。
在使用@RequestMapping后，返回值通常解析为跳转路径，加上@ResponseBody后返回结果不会被解析为跳转路径，而是直接写入HTTP Response Body中。
比如异步获取json数据，加上@ResponseBody后，会直接返回json数据。
该注解一般会配合@RequestMapping一起使用。
示例代码：
@RequestMapping(“/test”)
@ResponseBody
public String test(){
return ”ok”;
}
3、@Controller：用于定义控制器类，在spring 项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层）
一般这个注解在类中，通常方法需要配合注解@RequestMapping。
示例代码：
@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";
}
}
4、@RestController：用于标注控制层组件(如struts中的action)，@ResponseBody和@Controller的合集。
示例代码：
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(“/demoInfo2”)
publicclass DemoController2 {
@RequestMapping("/test")
public String test(){
return"ok";
}
}
5、@RequestMapping：提供路由信息，负责URL到Controller中的具体函数的映射。
6、@EnableAutoConfiguration：Spring Boot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。
例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库”。
你可以将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。
如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。
7、@ComponentScan：表示将该类自动发现扫描组件。
个人理解相当于，如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。
我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。可以自动收集所有的Spring组件，包括@Configuration类。
如果没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service、@Repository等注解的类。
8、@Configuration：相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。
9、@Import：用来导入其他配置类。
10、@ImportResource：用来加载xml配置文件。
11、@Autowired：自动导入依赖的bean
12、@Service：一般用于修饰service层的组件
13、@Repository：使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。
14、@Bean：用@Bean标注方法等价于XML中配置的bean。
15、@Value：注入Spring boot application.properties配置的属性的值。示例代码：
@Value(value = “#{message}”)
private String message;
16、@Inject：等价于默认的@Autowired，只是没有required属性；
17、@Component：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
18、@Bean：相当于XML中的,放在方法的上面，而不是类，意思是产生一个bean,并交给spring管理。
19、@AutoWired：自动导入依赖的bean。byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。当加上（required=false）时，就算找不到bean也不报错。
20、@Qualifier：当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，具体使用方式如下：
@Autowired @Qualifier(value = “demoInfoService”) private DemoInfoService demoInfoService;
21、@Resource(name=”name”,type=”type”)：没有括号内内容的话，默认byName。与@Autowired干类似的事。
三、JPA注解
1、@Entity：@Table(name=”“)：表明这是一个实体类。一般用于jpa这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table可以省略。
2、@MappedSuperClass:用在确定是父类的entity上。父类的属性子类可以继承。
3、@NoRepositoryBean:一般用作父类的repository，有这个注解，Spring不会去实例化该repository。
4、@Column：如果字段名与列名相同，则可以省略。
5、@Id：表示该属性为主键。
6、@GeneratedValue(strategy=GenerationType.SEQUENCE,generator= “repair_seq”)：表示主键生成策略是sequence（可以为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。
7、@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)：name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称可以一致。
8、@Transient：表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。
如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic。
9、@Basic(fetch=FetchType.LAZY)：标记可以指定实体属性的加载方式。
10、@JsonIgnore：作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
11、@JoinColumn（name=”loginId”）:一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。
12、@OneToOne、@OneToMany、@ManyToOne：对应hibernate配置文件中的一对一，一对多，多对一。
四、SpringMVC相关注解
1、@RequestMapping：@RequestMapping(“/path”)表示该控制器处理所有“/path”的URL请求。
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。
用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。该注解有六个属性：
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、@RequestParam：用在方法的参数前面。
3、@PathVariable:路径变量。如：
RequestMapping(“user/get/{macAddress}”)
public String getByMacAddress(@PathVariable String macAddress){
//do something;
}
参数与大括号里的名字一样要相同。
五、全局异常处理
@ControllerAdvice：包含@Component。可以被扫描到。统一处理异常。
@ExceptionHandler（Exception.class）：用在方法上面表示遇到这个异常就执行以下方法。
六、Lombok 注解
史上最全 Lombok Features 注解详解
一、@Getter and @Setter
使用@Getter和/或@Setter注释任何字段，以使lombok自动生成默认的getter / setter。
默认的getter只是返回该字段，如果该字段被称为foo，则名为getFoo（如果该字段的类型为boolean，则为isFoo）。
默认生成的 getter / setter方法是公共的，除非你明确指定一个AccessLevel。合法访问级别为PUBLIC，PROTECTED，PACKAGE和PRIVATE。
你还可以在类上添加@Getter和/或@Setter注释。在这种情况下，就好像你使用该注释来注释该类中的所有非静态字段一样。
你始终可以使用特殊的AccessLevel.NONE访问级别来手动禁用任何字段的getter / setter生成。这使你可以覆盖类上的@Getter，@Setter或@Data注释的行为。
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
public class GetterSetterExample {
@Getter
@Setter
private int age = 10;
@Setter(AccessLevel.PROTECTED)
private String name;
@Override
public String toString() {
return String.format("%s (age: %d)", name, age);
}
}
二、@ToString
任何类定义都可以使用@ToString注释，以使lombok生成toString()方法的实现。
默认情况下，将打印所有非静态字段。如果要跳过某些字段，可以使用@ ToString.Exclude注释这些字段。或者，可以通过使用@ToString（onlyExplicitlyIncluded = true），然后使用@ToString.Include标记要包含的每个字段，来确切指定希望使用的字段。
通过将callSuper设置为true，可以将toString的超类实现的输出包含到输出中。请注意，java.lang.Object中toString() 的默认实现几乎毫无意义。
With Lombok：
import lombok.ToString;
@ToString
public class ToStringExample {
private static final int STATIC_VAR = 10;
private String name;
private Shape shape = new Square(5, 10);
private String[] tags;
@ToString.Exclude
private int id;
public String getName() {
return this.name;
}
@ToString(callSuper=true, includeFieldNames=true)
public static class Square extends Shape {
private final int width, height;
public Square(int width, int height) {
this.width = width;
this.height = height;
}
}
}
三、@EqualsAndHashCode
任何类定义都可以使用@EqualsAndHashCode进行注释，以使lombok生成equals(Object other)和hashCode()方法的实现。默认情况下，它将使用所有非静态，非瞬态字段，但是您可以通过使用@EqualsAndHashCode.Include标记类型成员来修改使用哪些字段（甚至指定要使用各种方法的输出）。 @EqualsAndHashCode.Exclude。或者，可以通过使用@ EqualsAndHashCode.Include标记并使用@EqualsAndHashCode(onlyExplicitlyIncluded = true)来精确指定要使用的字段或方法。
如果将@EqualsAndHashCode应用于扩展另一个类的类，则此功能会有些棘手。通常，为此类自动生成equals和hashCode方法是一个坏主意，因为超类还定义了字段，该字段也需要equals / hashCode代码，但不会生成此代码。通过将callSuper设置为true，可以在生成的方法中包括超类的equals和hashCode方法。
With Lombok：
import lombok.EqualsAndHashCode;
@EqualsAndHashCode
public class EqualsAndHashCodeExample {
private transient int transientVar = 10;
private String name;
private double score;
@EqualsAndHashCode.Exclude
private Shape shape = new Square(5, 10);
private String[] tags;
@EqualsAndHashCode.Exclude
private int id;
public String getName() {
return this.name;
}
@EqualsAndHashCode(callSuper=true)
public static class Square extends Shape {
private final int width, height;
public Square(int width, int height) {
this.width = width;
this.height = height;
}
}
}
四、@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@NoArgsConstructor将生成没有参数的构造函数。如果字段由final修饰，则将导致编译器错误，除非使用@NoArgsConstructor(force = true)，否则所有final字段都将初始化为0 / false / null。对于具有约束的字段(例如@NonNull字段)，不会生成任何检查。
@RequiredArgsConstructor为每个需要特殊处理的字段生成一个带有1个参数的构造函数。所有未初始化的final字段都会获取一个参数，以及所有未声明其位置的未标记为@NonNull的字段。
@AllArgsConstructor为类中的每个字段生成一个带有1个参数的构造函数。标有@NonNull的字段将对这些参数进行空检查。
With Lombok：
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.NonNull;
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor(access = AccessLevel.PROTECTED)
public class ConstructorExample<T> {
private int x, y;
@NonNull
private T description;
@NoArgsConstructor
public static class NoArgsExample {
@NonNull
private String field;
}
}
五、@Data
@Data是一个方便的快捷方式批注，它将@ToString，@EqualsAndHashCode，@ Getter / @Setter和@RequiredArgsConstructor的功能捆绑在一起：换句话说，@Data生成通常与简单POJO关联的所有样板（普通的旧Java对象）和bean：所有字段的getter，所有非final字段的setter，以及涉及类字段的适当的toString，equals和hashCode实现，以及初始化所有final字段以及所有非final字段的构造函数没有使用@NonNull标记的初始化程序，以确保该字段永远不会为null。
With Lombok：
import lombok.AccessLevel;
import lombok.Setter;
import lombok.Data;
import lombok.ToString;
@Data
public class DataExample {
private final String name;
@Setter(AccessLevel.PACKAGE)
private int age;
private double score;
private String[] tags;
@ToString(includeFieldNames=true)
@Data(staticConstructor="of")
public static class Exercise<T> {
private final String name;
private final T value;
}
}
六、@Value
@Value注解和@Data类似，区别在于它会把所有成员变量默认定义为private final修饰，并且不会生成set方法。
七、@Builder
构建者模式
只能标注到类上，将生成类的一个当前流程的一种链式构造工厂，如下：
User buildUser = User.builder().username("riemann").password("123").build();
可配合@Singular注解使用，@Singular注解使用在jdk内部集合类型的属性，Map类型的属性以及Guava的com.google.common.collect 的属性上。例如 未标注@Singular的属性，一般setter时，会直接覆盖原来的引用，标注了@Singular的属性，集合属性支持添加操作，会在属性原来的基础上增加。
With Lombok：
import lombok.Builder;
import lombok.Singular;
import java.util.Set;
@Builder
public class BuilderExample {
@Builder.Default
private long created = System.currentTimeMillis();
private String name;
private int age;
@Singular
private Set<String> occupations;
}
八、@Accessors
链式风格
@Accessors批注用于配置lombok如何生成和查找getter和setter。
默认情况下，lombok遵循针对getter和setter的bean规范：例如，名为Pepper的字段的getter是getPepper。 但是，有些人可能希望打破bean规范，以得到更好看的API。 @Accessors允许您执行此操作。
可标注在类或属性上，当然最实用的功能还是标注到类上。
标注到类上，chain属性设置为true时，类的所有属性的setter方法返回值将为this，用来支持setter方法的链式写法。如：
new User().setUsername("riemann").setPassword("123");
fluent属性设置为true时，类的所有getter，setter方法将省略get和set前缀，获取属性值直接使用属性名相同的无参方法，设置属性值使用属性名相同的有参方法，并且返回值为this。如：
User user = new User().username("riemann").password("123");
String username = user.username();
String password = user.password();
标注到属性上，使用prefix设置需要省略的属性生成getter，setter方法时的前缀，且属性必须为驼峰式命名。
@Accessors(prefix = "r")
@Getter
@Setter
private String rUsername = "riemann";
编译之后为
public String getUsername() {
return rUsername;
}
public void setUsername(String rUsername) {
this.rUsername = rUsername;
}
九、@Slf4j and @Log4j
在需要打印日志的类中使用，项目中使用slf4j、log4j日志框架
十、@NonNull
该注解快速判断是否为空,为空抛出java.lang.NullPointerException。
十一、@Synchronized
注解自动添加到同步机制，生成的代码并不是直接锁方法,而是锁代码块， 作用范围是方法上。
十二、@Cleanup
注解用于确保已分配的资源被释放（IO的连接关闭）。
————————————————