Spring Boot进阶教程--注解大全

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的连接关闭）。
————————————————

Spring Boot @Enable*注解源码解析及自定义@Enable*

  Spring Boot 一个重要的特点就是自动配置，约定大于配置，几乎所有组件使用其本身约定好的默认配置就可以使用，大大减轻配置的麻烦。其实现自动配置一个方式就是使用@Enable*注解，见其名知其意也，即“使什么可用或开启什么的支持”。

Spring Boot 常用@Enable*

首先来简单介绍一下Spring Boot 常用的@Enable*注解及其作用吧。

1. @EnableAutoConfiguration 开启自动扫描装配Bean，组合成@SpringBootApplication注解之一
2. @EnableScheduling 开启计划任务的支持
3. @EnableTransactionManagement 开启注解式事务的支持。
4. @EnableCaching 开启注解式的缓存支持。
5. @EnableAspectJAutoProxy 开启对AspectJ自动代理的支持。
6. @EnableEurekaServer 开启Euraka Service 的支持，开启spring cloud的服务注册与发现
7. @EnableDiscoveryClient 开启服务提供者或消费者，客户端的支持，用来注册服务或连接到如Eureka之类的注册中心
8. @EnableFeignClients 开启Feign功能

还有一些不常用的比如：

1. @EnableAsync 开启异步方法的支持
2. @EnableWebMvc 开启Web MVC的配置支持。
3. @EnableConfigurationProperties 开启对@ConfigurationProperties注解配置Bean的支持。
4. @EnableJpaRepositories 开启对Spring Data JPA Repository的支持。

参考：http://tangxiaolin.com/learn/show?id=402881d2648c88cc01648c89d8730001

@Enable*的源码解析

查看它们的源码

@EnableAutoConfiguration

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

@EnableDiscoveryClient（@EnableEurekaServer 也是使用了这个组合注解） 开启服务提供者或消费者，客户端的支持，用来注册服务或连接到如Eureka之类的注册中心

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

@EnableFeignClients 开启Feign功能

@EnableScheduling（这个比较特殊，为自己直接新建相关类，不继承Selector和Registrar） 开启计划任务的支持

源码规律及解析

可以发现它们都使用了@Import注解（其中@Target:注解的作用目标，@Retention：注解的保留位置，@Inherited：说明子类可以继承父类中的该注解，@Document：说明该注解将被包含在javadoc中）

该元注解是被用来整合所有在@Configuration注解中定义的bean配置，即相当于我们将多个XML配置文件导入到单个文件的情形。

而它们所引入的配置类，主要分为Selector和Registrar，其分别实现了ImportSelector和ImportBeanDefinitionRegistrar接口，

两个的大概意思都是说，会根据AnnotationMetadata元数据注册bean类，即返回的Bean 会自动的被注入，被Spring所管理。

既然他们功能都相同，都是用来返回类，为什么 Spring 有这两种不同的接口类的呢？

其实刚开始的时候我也以为它们功能应该都是一样的，后面我在组内分享的时候，我的导师就问了我这个问题，然后当时我没有留意这个点所以答不出来。后面回去细看了一下和搜索了相关资料，发现它们的功能有些细微差别。首先我们从上面截图可以清楚地看到ImportBeanDefinitionRegistrar接口类中 registerBeanDefinitions方法多了一个参数 BeanDefinitionRegistry（点击这个参数进入看这个参数的Javadoc，可以知道，它是用于保存bean定义的注册表的接口），所以如果是实现了这个接口类的首先可以应用比较复杂的注册类的判断条件，例如：可以判断之前的类是否有注册到 Spring 中了。另外就是实现了这个接口类能修改或新增 Spring 类定义BeanDefinition的一些属性（查看其中一个实现了这个接口例子如：AspectJAutoProxyRegistrar，追查 BeanDefinitionRegistry参数可以查看到）。

具体实现例子@EnableDiscoveryClient

可以看一下具体的一个例子在@EnableDiscoveryClient引入了EnableDiscoveryClientImportSelector，通过查看其继承实现图

可以看到其最终实现了ImportSelector接口，查看其具体实现源码

知道其先得到父类注册的bean类，然后如果在查看AnnotationMetadata中是否存在autoRegister，是否需要注册该类，如果存在，则继续将org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration该类返回，加入到spring容器中。

源码小结

通过查看@Enable*源码，我们可以清楚知道其实现自动配置的方式的底层就是通过@Import注解引入相关配置类，然后再在配置类将所需的bean注册到spring容器中和实现组件相关处理逻辑去。

自定义@Enable*注解（EnableSelfBean）

  在这里我们利用@Import和ImportSelector动手自定义一个自己的EnableSelfBean。该Enable注解可以将某些包下的所有类自动注册到spring容器中，对于一些实体类的项目很多的情况下，可以考虑一下通过这种方式将某包下所有类自动加入到spring容器，不再需要每个类再加上@Component等注解。

1. 先创建一个spring boot项目。
2. 创建包entity，并新建类Role，将其放入到entity包中。

/**
 * 测试自己的自动注解的实体类
 * @author zhangcanlong
 * @since 2019/2/14 10:41
 **/
public class Role {
    public String test(){
     return "hello";
    }
}

1. 创建自定义配置类SelfEnableAutoConfig并实现ImportSelector接口。其中使用到ClassUtils类是用来获取自己某个包下的所有类的名称的。

/**
 * 自己的定义的自动注解配置类
 * @author zhangcanlong
 * @since 2019/2/14 10:45
 **/
public class SelfEnableAutoConfig implements ImportSelector {
    Logger logger = LoggerFactory.getLogger(SelfEnableAutoConfig.class);
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //获取EnableEcho注解的所有属性的value
        Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(EnableSelfBean.class.getName());
        if(attributes==null){return new String[0]; }
        //获取package属性的value
        String[] packages = (String[]) attributes.get("packages");
        if(packages==null || packages.length<=0 || StringUtils.isEmpty(packages[0])){
            return new String[0];
        }
        logger.info("加载该包所有类到spring容器中的包名为："+ Arrays.toString(packages));
        Set<String> classNames = new HashSet<>();

        for(String packageName:packages){
            classNames.addAll(ClassUtils.getClassName(packageName,true));
        }
        //将类打印到日志中
        for(String className:classNames){
            logger.info(className+"加载到spring容器中");
        }
        String[] returnClassNames = new String[classNames.size()];
        returnClassNames= classNames.toArray(returnClassNames);
        return  returnClassNames;
    }
}

ClassUtil类

/**
 * 获取所有包下的类名的工具类。参考：https://my.oschina.net/cnlw/blog/299265
 * @author zhangcanlong
 * @since 2019/2/14
 **/
@Component
public class ClassUtils {
	private static final String FILE_STR= "file";
	private static final String JAR_STR = "jar";

	/**
	 * 获取某包下所有类
	 * @param packageName 包名
	 * @param isRecursion 是否遍历子包
	 * @return 类的完整名称
	 */
	public static Set<String> getClassName(String packageName, boolean isRecursion) {
		Set<String> classNames = null;
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		String packagePath = packageName.replace(".", "/");
		URL url = loader.getResource(packagePath);
		if (url != null) {
			String protocol = url.getProtocol();
			if (FILE_STR.equals(protocol)) {
				classNames = getClassNameFromDir(url.getPath(), packageName, isRecursion);
			} else if (JAR_STR.equals(protocol)) {
				JarFile jarFile = null;
				try{
	                jarFile = ((JarURLConnection) url.openConnection()).getJarFile();
				} catch(Exception e){
					e.printStackTrace();
				}
				if(jarFile != null){
					getClassNameFromJar(jarFile.entries(), packageName, isRecursion);
				}
			}
		} else {
			/*从所有的jar包中查找包名*/
			classNames = getClassNameFromJars(((URLClassLoader)loader).getURLs(), packageName, isRecursion);
		}
		return classNames;
	}

	/**
	 * 从项目文件获取某包下所有类
	 * @param filePath 文件路径
	 * @param isRecursion 是否遍历子包
	 * @return 类的完整名称
	 */
	private static Set<String> getClassNameFromDir(String filePath, String packageName, boolean isRecursion) {
		Set<String> className = new HashSet<>();
		File file = new File(filePath);
		File[] files = file.listFiles();
		if(files==null){return className;}
		for (File childFile : files) {
			if (childFile.isDirectory()) {
				if (isRecursion) {
					className.addAll(getClassNameFromDir(childFile.getPath(), packageName+"."+childFile.getName(), isRecursion));
				}
			} else {
				String fileName = childFile.getName();
				if (fileName.endsWith(".class") && !fileName.contains("$")) {
					className.add(packageName+ "." + fileName.replace(".class", ""));
				}
			}
		}
		return className;
	}

	private static Set<String> getClassNameFromJar(Enumeration<JarEntry> jarEntries, String packageName, boolean isRecursion){
		Set<String> classNames = new HashSet<>();

		while (jarEntries.hasMoreElements()) {
			JarEntry jarEntry = jarEntries.nextElement();
			if(!jarEntry.isDirectory()){
				String entryName = jarEntry.getName().replace("/", ".");
				if (entryName.endsWith(".class") && !entryName.contains("$") && entryName.startsWith(packageName)) {
					entryName = entryName.replace(".class", "");
					if(isRecursion){
						classNames.add(entryName);
					} else if(!entryName.replace(packageName+".", "").contains(".")){
						classNames.add(entryName);
					}
				}
			}
		}
		return classNames;
	}

	/**
	 * 从所有jar中搜索该包，并获取该包下所有类
	 * @param urls URL集合
	 * @param packageName 包路径
	 * @param isRecursion 是否遍历子包
	 * @return 类的完整名称
	 */
	private static Set<String> getClassNameFromJars(URL[] urls, String packageName, boolean isRecursion) {
		Set<String> classNames = new HashSet<>();
		for (URL url : urls) {
			String classPath = url.getPath();
			//不必搜索classes文件夹
			if (classPath.endsWith("classes/")) {
				continue;
			}
			JarFile jarFile = null;
			try {
				jarFile = new JarFile(classPath.substring(classPath.indexOf("/")));
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (jarFile != null) {
				classNames.addAll(getClassNameFromJar(jarFile.entries(), packageName, isRecursion));
			}
		}
		return classNames;
	}
}

折叠

1. 创建自定义注解类EnableSelfBean

/**
 * 自定义注解类，将某个包下的所有类自动加载到spring 容器中，不管有没有注解，并打印出
 * @author zhangcanlong
 * @since 2019/2/14 10:42
 **/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(SelfEnableAutoConfig.class)
public @interface EnableSelfBean {
    //传入包名
    String[] packages() default "";
}

1. 创建启动类SpringBootEnableApplication

@SpringBootApplication
@EnableSelfBean(packages = "com.kanlon.entity")
public class SpringBootEnableApplication {
    @Autowired
    Role abc;

    public static void main(String[] args) {
        ConfigurableApplicationContext context =  SpringApplication.run(SpringBootEnableApplication.class, args);
        //打印出所有spring中注册的bean
        String[] allBeans = context.getBeanDefinitionNames();
        for(String bean:allBeans){
            System.out.println(bean);
        }
        System.out.println("已注册Role："+context.getBean(Role.class));
        SpringBootEnableApplication application = context.getBean(SpringBootEnableApplication.class);
        System.out.println("Role的测试方法："+application.abc.test());
    }
}

启动类测试的一些感悟：重新复习了回了spring的一些基础东西，如：

1. @Autowired是默认通过by type（即类对象）得到注册的类，如果有多个实现才使用by name来确定。
2. 所有注册的类的信息存储在ApplicationContext中，可以通过ApplicationContext得到注册类，这个是很基础的，但是真的很久没看，没想到竟然又忘记了。
3. Spring boot中如果@ComponentScan没有，则默认是指扫描当前启动类所在的包里的对象。