趣學Spring：一文搞懂Aware、非同步程式設計、計劃任務
你好呀，我是沉默王二，一個和黃家駒一樣身高，劉德華一樣顏值的程式設計師（不信圍觀朋友圈唄）。從 2 位偶像的年紀上，你就可以斷定我的碼齡至少在 10 年以上，但實話實說，我一直堅信自己只有 18 歲，因為好學使我年輕。本篇文章就打算通過我和三妹對話的形式來聊一聊“Spring 的 Aware、非同步程式設計、計劃任務”。
教妹學 Spring，沒見過這麼放肆的標題吧？“語不驚人死不休”，沒錯，本篇文章的標題就是這麼酷炫，不然你怎麼會點進來？
我有一個漂亮如花的妹妹（見上圖，怎麼又變了？還不能一天做個夢），她叫什麼呢？我想聰明的讀者能猜得出：沉默王三，沒錯，年方三六。父母正考慮讓她向我學習，做一名正兒八經的 Java 程式設計師。我一開始是反對的，因為程式設計師這行業容易掉頭髮，女生可不適合掉頭髮。但家命難為啊，與其反對，不如做點更積極的事情，比如說寫點有趣的文章教教她。
“二哥，聽說今天要學習 Spring 的 Aware、非同步程式設計、計劃任務，真的是翹首以盼啊。”
“哎呀，三妹，瞧你那迫不及待的大眼神，就好像昨晚上月亮一樣圓，一樣大。”
01、Spring Aware
“二哥，據說 Aware 的目的是讓 Bean 獲取 Spring 容器的服務，你能給我具體說說嗎？”
“沒問題啊。”
Bean 一般不需要了解容器的狀態和直接使用容器，但是在某些情況下，需要在 Bean 中直接對容器進行操作，這時候，就可以通過特定的 Aware 介面來完成。常見的 Spring Aware 介面有下面這些：
| Aware 子介面 | 描述 |
|---|---|
| BeanNameAware | 獲取容器中 Bean 的名稱 |
| BeanFactoryAware | Bean 被容器建立以後，會有一個相應的 BeanFactory，可以直接通過它來訪問容器 |
| ApplicationContextAware | Bean 被初始化後，會被注入到 ApplicationContext，可以直接通過它來訪問容器 |
| MessageSourceAware | 獲取 Message Source 的相關文字資訊 |
| ResourceLoaderAware | 獲取資源載入器，以獲取外部資原始檔 |
1）BeanNameAware
新建一個 MyBeanName 類，內容如下：
public class MyBeanName implements BeanNameAware {
@Override
public void setBeanName(String beanName) {
System.out.println(beanName);
}
}
MyBeanName 實現了 BeanNameAware 介面，並重寫了 setBeanName() 方法。beanName 引數表示 Bean 在 Spring 容器中註冊的 name。
新建一個 Config 類，內容如下：
@Configuration
public class Config {
@Bean(name = "myCustomBeanName")
public MyBeanName getMyBeanName() {
return new MyBeanName();
}
}
@Bean 註解用在 getMyBeanName() 方法上，表明當前方法返回一個 Bean 物件（MyBeanName），並通過 name 屬性指定 Bean 的名字為“myCustomBeanName”。
新建 BeanNameMain 類，程式碼如下：
public class BeanNameMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanNameConfig.class);
MyBeanName myBeanName = context.getBean(MyBeanName.class);
context.close();
}
}
程式輸出的結果如下所示：
myCustomBeanName
如果把 @Bean() 註解中的 (name = "myCustomBeanName)" 去掉的話，程式輸出的內容將會是 BeanNameConfig 類的 getMyBeanName() 的方法名“getMyBeanName”。
2）BeanFactoryAware
新建一個 MyBeanFactory 類，內容如下：
public class MyBeanFactory implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
public void getMyBeanName() {
MyBeanName myBeanName = beanFactory.getBean(MyBeanName.class);
System.out.println(beanFactory.isSingleton("myCustomBeanName"));
System.out.println(beanFactory.isSingleton("getMyBeanFactory"));
}
}
藉助 setBeanFactory() 方法，可以將容器中的 BeanFactory 賦值給 MyBeanFactory 類的成員變數 beanFactory，這樣就可以在 getMyBeanName() 方法中使用 BeanFactory 了。
通過 getBean() 方法可以獲取 Bean 的例項；通過 isSingleton() 方法判斷 Bean 是否為一個單例。
在 Config 類中追加 MyBeanFactory 的 Bean：
@Configuration
public class Config {
@Bean(name = "myCustomBeanName")
public MyBeanName getMyBeanName() {
return new MyBeanName();
}
@Bean
public MyBeanFactory getMyBeanFactory() {
return new MyBeanFactory();
}
}
新建 BeanFactoryMain 類，程式碼如下：
public class BeanFactoryMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
MyBeanFactory myBeanFactory = context.getBean(MyBeanFactory.class);
myBeanFactory.getMyBeanName();
context.close();
}
}
初始化 MyBeanFactory 後就可以呼叫 getMyBeanName() 方法了，程式輸出的結果如下所示：
myCustomBeanName
true
true
結果符合我們的預期：MyBeanName 的名字為“myCustomBeanName”，MyBeanName 和 MyBeanFactory 的 scope 都是 singleton。
3）其他幾個 Aware 介面就不再舉例說明了。通常情況下，不要實現 Aware 介面，因為它會使 Bean 和 Spring 框架耦合。
02、非同步程式設計
“二哥，據說 Spring 可以通過 @Async 來實現非同步程式設計，你能給我詳細說說嗎？”
“沒問題啊。”
新建一個 AsyncService 類，內容如下：
public class AsyncService {
@Async
public void execute() {
System.out.println(Thread.currentThread().getName());
}
}
@Async 註解用在 public 方法上，表明 execute() 方法是一個非同步方法。
新建一個 AsyncConfig 類，內容如下：
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public AsyncService getAsyncService() {
return new AsyncService();
}
}
在配置類上使用 @EnableAsync 註解用以開啟非同步程式設計，否則 @Async 註解不會起作用。
新建一個 AsyncMain 類，內容如下：
public class AsyncMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AsyncConfig.class);
AsyncService service = context.getBean(AsyncService.class);
for (int i = 0; i < 10; i++) {
service.execute();
}
}
程式輸出結果如下：
SimpleAsyncTaskExecutor-1
SimpleAsyncTaskExecutor-9
SimpleAsyncTaskExecutor-7
SimpleAsyncTaskExecutor-8
SimpleAsyncTaskExecutor-10
SimpleAsyncTaskExecutor-3
SimpleAsyncTaskExecutor-2
SimpleAsyncTaskExecutor-4
SimpleAsyncTaskExecutor-6
SimpleAsyncTaskExecutor-5
OK，結果符合我們的預期，非同步程式設計實現了。就像你看到的那樣，Spring 提供了一個預設的 SimpleAsyncTaskExecutor 用來執行執行緒，我們也可以在方法級別和應用級別上對執行器進行配置。
1）方法級別
新建 AsyncConfig 類，內容如下：
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public AsyncService getAsyncService() {
return new AsyncService();
}
@Bean(name = "threadPoolTaskExecutor")
public Executor threadPoolTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
return executor;
}
}
在配置類中建立了一個返回型別為 Executor 的 Bean，其名稱定義為“threadPoolTaskExecutor”，並且重新設定了 ThreadPoolTaskExecutor 的核心執行緒池大小，預設為 1，現在修改為 5。
新進 AsyncService 類，內容如下：
public class AsyncService {
@Async("threadPoolTaskExecutor")
public void execute() {
System.out.println(Thread.currentThread().getName());
}
}
@Async 註解上需要指定我們之前配置的執行緒池執行器“threadPoolTaskExecutor”。
新建 AsyncMain 類，內容如下：
public class AsyncMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AsyncConfig.class);
AsyncService service = context.getBean(AsyncService.class);
for (int i = 0; i < 10; i++) {
service.execute();
}
}
}
程式執行結果如下：
threadPoolTaskExecutor-1
threadPoolTaskExecutor-2
threadPoolTaskExecutor-4
threadPoolTaskExecutor-3
threadPoolTaskExecutor-5
threadPoolTaskExecutor-3
threadPoolTaskExecutor-2
threadPoolTaskExecutor-4
threadPoolTaskExecutor-1
threadPoolTaskExecutor-5
從結果中可以看得出，執行緒池執行器變成了“threadPoolTaskExecutor”，並且大小為 5。
2）應用級別
新建 AsyncConfig 類，內容如下：
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
@Bean
public AsyncService getAsyncService() {
return new AsyncService();
}
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(3);
executor.initialize();
return executor;
}
}
需要實現 AsyncConfigurer 介面，並重寫 getAsyncExecutor() 方法，這次設定執行緒池的大小為 3。注意執行器要執行一次 initialize() 方法。
新進 AsyncService 類，內容如下：
public class AsyncService {
@Async
public void execute() {
System.out.println(Thread.currentThread().getName());
}
}
新建 AsyncMain 類，內容如下：
public class AsyncMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AsyncConfig.class);
AsyncService service = context.getBean(AsyncService.class);
for (int i = 0; i < 10; i++) {
service.execute();
}
}
}
程式執行結果如下：
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-2
ThreadPoolTaskExecutor-1
ThreadPoolTaskExecutor-3
從結果中可以看得出，執行緒池執行器變成了“ThreadPoolTaskExecutor”，並且大小為 3。
03、計劃任務
“二哥，據說 Spring 可以通過 @Scheduled 來實現計劃任務，你能給我詳細說說怎麼實現嗎？”
“沒問題啊。”
新建一個 ScheduledService 類，內容如下：
@Service
public class ScheduledService {
@Scheduled(fixedDelay = 1000)
public void scheduleFixedDelayTask() {
System.out.println(
"固定時間段後執行任務 - " + System.currentTimeMillis() / 1000);
}
@Scheduled(fixedRate = 1000)
public void scheduleFixedRateTask() {
System.out.println(
"固定的頻率執行任務 - " + System.currentTimeMillis() / 1000);
}
@Scheduled(cron = "0/2 * * * * ?")
public void scheduleTaskUsingCronExpression() {
long now = System.currentTimeMillis() / 1000;
System.out.println(
"Cron 表示式執行任務 - " + now);
}
}
@Service 註解用於指定 ScheduledService 類為一個業務層的 Bean。@Scheduled 註解用於指定當前方法（返回型別為 void，無參）為一個任務執行方法，常見的用法有以下 3 種：
1）fixedDelay 用於確保任務執行的完成時間與任務下一次執行的開始時間之間存在 n 毫秒的延遲，下一次任務執行前，上一次任務必須執行完。
2）fixedRate 用於確保每 n 毫秒執行一次計劃任務，即使最後一次呼叫可能仍在執行。
3）Cron 表示式比 fixedDelay 和 fixedRate 都要靈活，由 7 個部分組成，各部分之間用空格隔開，其完整的格式如下所示：
Seconds Minutes Hours Day-of-Month Month Day-of-Week Year
單詞都很簡單，就不用我翻譯了。其中 Year 是可選項。常見的範例如下所示：
*/5 * * * * ? 每隔 5 秒執行一次
0 */1 * * * ? 每隔 1 分鐘執行一次
0 0 23 * * ? 每天 23 點執行一次
0 0 1 * * ? 每天凌晨 1 點執行一次：
0 0 1 1 * ? 每月 1 號凌晨 1 點執行一次
0 0 23 L * ? 每月最後一天 23 點執行一次
0 0 1 ? * L 每週星期天凌晨 1 點執行一次
0 26,29,33 * * * ? 在 26 分、29 分、33 分執行一次
0 0 0,13,18,21 * * ? 每天的 0 點、13 點、18 點、21 點各執行一次
新建 ScheduledConfig 類，內容如下：
@Configuration
@EnableScheduling
@ComponentScan("high.scheduled")
public class ScheduledConfig {
}
@EnableScheduling 註解用於開啟計劃任務。@ComponentScan 註解用於掃描當前包下的類，如果它使用了註解（比如 @Service），就將其註冊成為一個 Bean。
新建 ScheduledMain 類，內容如下：
public class ScheduledMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ScheduledConfig.class);
}
}
程式執行結果如下：
固定的頻率執行任務 - 1584666273
固定時間段後執行任務 - 1584666273
Cron 表示式執行任務 - 1584666274
固定的頻率執行任務 - 1584666274
固定時間段後執行任務 - 1584666274
固定的頻率執行任務 - 1584666275
固定時間段後執行任務 - 1584666275
Cron 表示式執行任務 - 1584666276
從結果中可以看得出，如果任務之間沒有衝突的話，fixedDelay 任務之間的間隔和 fixedRate 任務之間的間隔是相同的，都是 1 秒；Cron 表示式任務與上一次任務之間的間隔為 2 秒。
“二哥，這篇文章中的示例程式碼你上傳到 GitHub 了嗎？”
“你到挺貼心啊，三妹。傳送門~”
“二哥，你教得真不錯，我完全學會了，一點也不枯燥。”
“那必須得啊，期待下一篇吧？”
“那是當然啊，期待，非常期待，望眼欲穿的感覺。”
請允許我熱情地吐槽一下，這篇文章我不希望再被噴了，看在我這麼辛苦搞原創（創意+乾貨+有趣）的份上，多鼓勵鼓勵好不好？別瞅了，點讚唄，你最美你最帥。
如果覺得文章對你有點幫助，請微信搜尋「 沉默王二 」第一時間閱讀，回覆【666】【1024】更有我為你精心準備的 500G 高清教學視訊（已分門別類），以及大廠技術牛人整理的面經一份。