Spring IoC容器（ApplicationContext）负责创建Bean，并通过容器将功能类Bean注入到需要的Bean中。Spring提供使用xml、注解、Java配置实现Bean的创建和注入。
可见，注解在Spring的使用中占据非常重要的地位，虽然Spring 4.x及Spring Boot中推荐使用Java配置，但注解的使用仍然不可完全丢弃。项目中常常根据开发者的习惯和二者优势而选择，或混合使用。通常，涉及到全局配置的如数据库相关配置、MVC相关配置等，使用JAVA配置方式。而涉及业务配置的，使用注解方式。
本文简单的介绍一些Spring的常用注解，官方文档有更详细准确的介绍，小伙伴们可根据需要详细研读：
https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/

一、声明Bean的注解：

1）@Component组件，没有明确的角色
2）@Service在业务逻辑层（Service层）使用
3）@RepoSitory在数据访问层（dao层）使用
4）@Controller在展示层（Spring MVC）使用

• Bean的scope有以下几种，在新建Bean实例时，可配合@Scope注解设置Bean的Scope。
  1）Singleton:单一实例，全容器共享一个实例，此为Spring的默认配置。
  2）Prototype：每次调用新建一个Bean的实例。
  3）Request：Web项目中，给每一个http request新建一个Bean实例。
  4）Session：Web项目中，黑每一个http session新建一个Bean实例。
  5）GlobalSession：这个只会在portal应用中有用，给每一个global http session 新建一个Bean实例。
• Bean的初始化和销毁：
  1）Java配置方式：使用@Bean的initMethod和destoryMethod指定
  2）注解方式：使用JSR-250的@PostConstruct和@PreDestroy
  例如：Java配置方式

public class Car {public Car() {System.out.println("Car's Constructor..");}public void init(){System.out.println("Car's Init...");}public void destory(){System.out.println("Car's Destroy...");}
}
@Configuration
public class AppConfig {@Bean(initMethod = "init",destroyMethod = "destory")public Car car() {return new Car();}
}

例如：注解方式

public Class AAA {@Autowiredprivate BBB b;public AAA() {System.out.println("此时b还未被注入: b = " + b);}@PostConstructprivate void init() {System.out.println("将在依赖注入完成后被调用: b = " + b);}@PreDestroyprivate void destroy() {//xxx}
}

• 如果需要在项目启动后执行某功能，只需实现CommandLineRunner接口，将启动时执行的业务逻辑放过在run方法中。

@Component
public class MyStartupRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {System.out.println("服务启动执行...");
}
}

• 如果有多个类实现CommandLineRunner接口，为保证顺序，需要在实体类上使用一个@Order注解，执行时按value值从小到大顺序。

@Component
@Order(value=2)
public class MyStartupRunner1 implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {System.out.println("服务启动执行 2222");}
}

@Component
@Order(value=1)
public class MyStartupRunner2 implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {System.out.println("服务启动执行 111111");}
}

二、注入Bean的注解：

1）@Autowired：Spring提供的注解
2）@ReSource:JSR-250提供的注解
3）@Inject:JSR-330提供的注解

详细介绍：
1）@Autowired：是spring自带的注解，类型进行自动装配的，如果需要按名称进行装配，则需要配合@Qualifier。@Autowired有个属性为required，可以配置为false，如果配置为false之后，当没有找到相应bean的时候，系统不会报错。@Autowired可以作用在变量、setter方法、构造函数上。
@Qualifier(“XXX”) 中的 XX是 Bean 的名称，所以 @Autowired 和 @Qualifier 结合使用时，自动注入的策略就从 byType 转变成 byName 了。不过需要注意的是@Autowired 可以对成员变量、方法以及构造函数进行注释，而 @Qualifier 的标注对象是成员变量、方法入参、构造函数入参。
例如：

public void setDataSource(@Qualifier("myDataSource")Datasource dataSource){super.setDataSource(dataSource);
}

2）@Resource：是JSR250规范的实现，需要导入javax.annotation实现注入。@Resource是根据名称进行自动装配的，一般会指定一个name属性（也可以不指定，会使用类名首字母小写作为name）。可作用在变量、setter方法上。

public class SimpleMovieListener {private MovieFinder movieFinder;@Resource(name = "myMovieFinder")public void setMovieFinder(MovieFinder movieFinder) {this.movieFinder = movieFinder;}
}

3）@Inject：是JSR330 (Dependency Injection for Java)中的规范，需要导入javax.inject.Inject;实现注入。@Inject是根据类型进行自动装配的，如果需要按名称进行装配，则需要配合@Named；可作用在变量、setter方法、构造函数上。用法和@Autowired一样。

public class SimpleMovieListener {private MovieFinder movieFinder;@Injectpublic void setMovieFinder(MovieFinder movieFinder) {this.movieFinder = movieFinder;}
}

    @Named(“XXX”) 中的 XX是 Bean 的名称，所以 @Inject和 @Named结合使用时，自动注入的策略就从 byType 转变成 byName 了。

public class SimpleMovieListener {private MovieFinder movieFinder;@Injectpublic void setMovieFinder(@Named("main") MovieFinder movieFinder) {this.movieFinder = movieFinder;}
}

三、配置类注解：

1）@Configuration:声明当前类是一个配置类
2）@ComponentScan:自动扫描包下所有使用@Service、@Component、@Repository、@Controller的类，并注册为Bean

四、Java配置注解：

1）@Configuration:声明当前类是一个配置类，相当于一个Spring配置的xml文件
2）@Bean注解在方法上，声明当前方法的返回值为一个Bean
例如：

@Configuration 
public class AppConfig {@Beanpublic MyBean myBean() {// instantiate, configure and return bean ...}}

还可以配合@Profile注解使用，如下：

@Configurationpublic
public class AppConfig {@Profile("english")@Beanpublic English getEnglish() { return new English(); }@Profile("chinese")@Bean
public Chinese getChinese() { return new Chinese(); }}// 测试类public class Test {public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();applicationContext.getEnvironment().setActiveProfiles("chinese");applicationContext.register(AppConfig.class);applicationContext.refresh();String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();for (String beanDefinitionName : beanDefinitionNames){System.out.println(beanDefinitionName); }}}

    也可以配合@Lazy使用，没加注解之前主要容器启动就会实例化bean，加上@Lazy注解则必须在第一次调用的时候才会加载，其作用主要是减少springIOC容器启动的加载时间。例如：

@Configuration
public class MainConfig {@Lazy@Bean("user")public User user() {System.out.println("给容器中添加user....");return new User("张三", 28);}}

五、资源注入类注解：@Value ，用于注入不同的资源

常见用法如下：
1）基本数值：

@Value("张三")
private String name;

2）SpringEL：#{}

//注入操作系统属性
@Value("#{systemProperties['os.name']}")
private String osName;//注入表达式结果
@Value("#{ T(java.lang.Math).random()*100.0 }")
private double randomNumber;//注入其他Bean的属性
@Value("#{demoService.another}")
private String fromAuther;

3)文件&网站资源：

//注入文件资源
@Value("classpath:com/xxx/xxx.txt")
private Resource testFile;//注入网址资源
@Value("http://www.baidu.com")
private Resource testFile;

4)配置文件资源：${}

@Value("${person.nickName}")
private String nickName;

    如果配置文件不是默认的application.properties，需要使用@PropertySource注解指定。

@Component
@PropertySource("classpath:user.properties")
@ConfigurationProperties(prefix = "user")
public class User {private String userName;private Integer age;// set get省略...
}

六、多线程注解：

1）@EnableAsync:在配置类中通过该注解开启对异步任务的支持
2）@Async：在Bean中使用该注解声明一个异步任务

    使用时，编写自定义配置类，实现AsyncConfigurer接口，覆盖其getAsyncExecutor()、getAsyncUncaughtExceptionHandler()方法，分别用来获取Executors及进行异步执行的异常处理。并在该类上使用@EnableAsync开启对异步的支持。
例如：

package ds.watsons.app.label.config;
import java.util.concurrent.Executor;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;@Configurable
@EnableAsync
public class TreadPoolConfigTest implements AsyncConfigurer{
@Override
public Executor getAsyncExecutor() {// TODO Auto-generated method stubThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();//核心线程池数量，方法: 返回可用处理器的Java虚拟机的数量。executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
//最大线程数量executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors()*5);
//线程池的队列容量
executor.setQueueCapacity(Runtime.getRuntime().availableProcessors()*2);
//线程名称的前缀
executor.setThreadNamePrefix("this-excutor-");
// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务
// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行
//executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;}/*异步任务中异常处理*/@Overridepublic AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {// TODO Auto-generated method stubreturn new SimpleAsyncUncaughtExceptionHandler();}       }  

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;@Component
public class TreadTasks {@Asyncpublic void startMyTreadTask() {System.out.println("my async task");}}

    调用异步线程任务：

@Controller
public class AsyncTaskUse {@Autowiredprivate TreadTasks treadTasks;@GetMapping("/startMysync")public void useMySyncTask() {treadTasks.startMyTreadTask();}
}

七、计划任务注解：

1）@EnableScheduling :开启对计划任务的支持
2）@Scheduled：在计划任务方法上使用，支持多种计划任务类型，包括：cron、fixDelay、fixRate

    @EnableScheduling在启动类或配置类上使用：

@SpringBootApplication
@EnableScheduling //开启定时任务
public class MainApplication {public static void main(String[] args) {SpringApplication.run(MainApplication.class, args);}
}

@Component
public class Jobs {//表示方法执行完成后5秒@Scheduled(fixedDelay = 5000)public void fixedDelayJob() throws InterruptedException {System.out.println("fixedDelay 每隔5秒" + new Date());}//表示每隔3秒@Scheduled(fixedRate = 3000)public void fixedRateJob() {System.out.println("fixedRate 每隔3秒" + new Date());}//表示每天8时30分0秒执行@Scheduled(cron = "0 0,30 0,8 ? * ? ")public void cronJob() {System.out.println(new Date() + " ...>>cron....");}
}

八、条件注解：

• @Conditional:在满足一个特定条件时创建一个Bean。该注解需搭配 Condition接口使用，重写其matches方法来构造判断条件。
  例如：当配置文件中有create.bean时则会创建Product，否则不创建。

public class ProductCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {//从配置文件中获取属性String property=conditionContext.getEnvironment().getProperty("create.bean");if (property != null){return property.contains("product");} else {return false;}}
}

@Configuration
public class ProductConfig {@Conditional(ProductCondition.class)@Bean(name = "product")public Product createProd(){return Product.builder().id(12312).categoryId(12).productName("Mac Book Pro").productImg("prod.png").productPrice(18000).build();}
}

• @ConditionalOnClass:某个类存在，则创建Bean。

@Configurationpublic 
class ProductConfig {@ConditionalOnClass(name = "com.roseduan.demo.entity.Product")@Bean(name = "product")public Product createProd(){return Product.builder().id(12312).categoryId(12).productName("Mac Book Pro").productImg("prod.png").productPrice(18000).build();}
}

• @ConditionalOnProperty：直接从配置文件中获取属性，做为是否创建 bean 的依据，为true则创建。

@Configuration
public class ProductConfig {@ConditionalOnProperty(value = "create.product.bean")@Bean(name = "product")public Product createProd(){return Product.builder().id(12312).categoryId(12).productName("Mac Book Pro").productImg("prod.png").productPrice(18000).build();}
}

九、测试注解：

1）@RunWith(SpringJUnit4ClassRunner.class):使用Junit测试框架
2) 加载配置，使用配置文件和Java配置方式分别如下：
@ContextConfiguration(locations={“classpath*:spring-mybatis.xml”})
@ContextConfiguration(class={“TestConfig.class”})
3) @ActiveProfiles(“prod”):声明活动的profile
4) @Test:标注测试方法

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest { @Autowired private UserService userService; @Test public void testUserService(){ userService.save(); } 
}  

十、Spring MVC常用注解：

1）@Controller:在类上使用，该类为SpringMVC Controller 对象
2）@RequestMapping:用来映射web请求（访问路径和参数）、处理类和方法的。可注解在类或方法上。注解在方法上的@RequestMapping路径会继承注解在类上的路径。

• @RequestMapping注解有6大属性：
  ① value：指定请求的实际地址，指定的地址可以是URI Template 模式
  ② method：指定请求的method类型， GET、POST、PUT、DELETE等
  ③ consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html
  ④ produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回
  ⑤ params： 指定request中必须包含某些参数值是，才让该方法处理
  ⑥ headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求

@RequestMapping(value="/{day}", method = RequestMethod.GET)
public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {return appointmentBook.getAppointmentsForDay(day);
}

//处理request Content-Type为“application/json”类型的请求
@Controller
@RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json")
public void addPet(@RequestBody Pet pet, Model model) {    // implementation omitted
}

//仅处理request请求中Accept头中包含了"application/json"的请求，同时暗示了返回的内容类型为application/json
@Controller
@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json")
@ResponseBody
public Pet getPet(@PathVariable String petId, Model model) {    // implementation omitted
}

//仅处理请求中包含了名为“myParam”，值为“myValue”的请求
@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    // implementation omitted  }
}

//仅处理request的header中包含了指定“Refer”请求头和对应值为“http://www.ifeng.com/”的请求
@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {@RequestMapping(value = "/pets", method = RequestMethod.GET,headers="Referer=http://www.ifeng.com/")public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    // implementation omitted 
}
}

3）ResponseBody:指定接口返回数据，而不是对象
4）@RequestBody:用在参数前，指定请求参数放在请求体中，而不是链接在地址后面。一般用来处理content-type为application/json类型。

@PostMapping("/2")
public String user2String(@RequestBody User user){return user.toString();
}

5）@PathVariable：放在参数前，用来接收路径参数

@RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
public String getProduct(@PathVariable("productId") String productId){  System.out.println("Product Id : " + productId);  return "hello";  
} 

6）@RestController:相当于@ResponseBody ＋ @Controller合在一起的作用,用于定义一个返回数据（而不是页面）的web接口。

十一、Spring Boot常用注解：

• @SpringBootApplication：该注解包含了@ComponentScan、@Configuration和@EnableAutoConfiguration。
  其中，@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。
  @Configuration 等同于spring的XML配置文件；使用Java代码可以检查类型安全。
  @EnableAutoConfiguration 开启自动配置。
  该注解通常用在Spring Boot启动类上：

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