2. 程式人生 > >SpringBoot4-spring高階話題-spring aware，多執行緒，計劃任務，條件註解@Conditional

SpringBoot4-spring高階話題-spring aware，多執行緒，計劃任務，條件註解@Conditional

阿新 • • 發佈：2019-02-15

一：Spring Aware

1，點睛

     spring的依賴注入的最大亮點就是你所有的Bean對Spring容器的存在是沒有意識的，即你可以將你的容器替換成別的容器，如Google Guice，這時Bean之間的耦合度很低。

    但是在實際專案中，你不可避免的要用到Spring容器本身的功能資源，這時你的Bean必須意識到Spring容器的的存在，才能呼叫Spring所提供的資源，這就是所謂的Spring Aware。其實Spring Aware本來就是Spring設計用來框架內容使用的，若使用了Spring Aware，你的Bean將會和Spring框架耦合。

   Spring提供的Aware介面如下：

BeanNameAware：獲得容器中的bean名稱

BeanFactoryAware：獲得當前bean factory，這樣就可以呼叫容器的服務

ApplicationContextAwate*：當前application context，這樣可以呼叫容器的服務

MessageSourceAware：獲得message source，這樣可以獲得文字資訊

ApplicationEventPublisherAware：應用時間釋出器，可以釋出事件

ResourceLoaderAware：獲得資源載入器，可以獲得外部資原始檔

Spring Aware的目的是為了讓Bean獲得Spring容器的服務。因為ApplicationContext介面集成了MessageSource介面，ApplicationEventPublisher介面和ResourceLoader介面，所以Bean繼承ApplicationContextAware可以獲得Spring容器的所有服務，但原則上我們還是用到什麼介面，就實現什麼介面。

    示例如下：

    在jack.ch3.aware包下新建一個test.txt，內容隨意，給下面的外部資源載入使用。

   Spring Aware演示Bean：

package jack.ch3.aware;

import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Service;

/**
 * Created by jack on 2017/7/11.
 */
//實現BeanNameAware,ResourceLoaderAware介面，獲得Bean名稱和資源載入的服務
@Service
public class AwareService implements BeanNameAware,ResourceLoaderAware{
    private String beanName;
    private ResourceLoader loader;
    //實現BeanNameAware需重寫setBeanName
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }

    //實現ResourceLoaderAware需重寫setResourceLoader
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.loader = resourceLoader;
    }

    public void outputResult(){
        System.out.println("Bean的名稱為："+beanName);
        Resource resource = loader.getResource("classpath:jack/ch3/aware/test.txt");
        try {
            System.out.println("ResourceLoader載入檔案內容為： "+ IOUtils.toString(resource.getInputStream()));
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}


  配置類：

package jack.ch3.aware;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * Created by jack on 2017/7/11.
 */
@Configuration
@ComponentScan("jack.ch3.aware")
public class AwareConfig {
}


 測試程式碼如下：

package jack.ch3.aware;

import jack.ch2.event.DemoPublisher;
import jack.ch2.event.EventConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * Created by jack on 2017/7/11.
 */
public class MainTest9 {
    public static void main(String [] args){
        //AnnotationConfigApplicationContext作為spring容器，接受一個配置類作為引數
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AwareConfig.class);
        AwareService awareService = context.getBean(AwareService.class);
        awareService.outputResult();
        context.close();
    }
}


  執行測試程式，結果如下：


二：多執行緒

   spring通過任務執行器（TaskExecutor）來實現多執行緒和併發程式設計。使用ThreadPoolTaskExecutor可實現一個基於執行緒池的TaskExecutor。而實際開發中任務一般是非阻礙的，即非同步的，所以我們要在配置類中通過@EnableAsync開啟對非同步任務的支援，並通過在實際執行的Bean的方法中使用@Async註解宣告其是一個非同步任務。

    下面是示例：

    配置類：

package jack.ch3.taskexecutor;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * Created by jack on 2017/7/15.
 */
@Configuration
@ComponentScan("jack.ch3.taskexecutor")
@EnableAsync//利用@EnableAsync註解開啟非同步任務支援
/**
 * 配置類實現AsyncConfigurer介面，並重寫getAsyncExecutor方法，並返回一個ThreadPoolTaskExecutor，這樣我們就獲得一個基於
 * 執行緒池TaskExecutor
 */
public class TaskExecutorConfig implements AsyncConfigurer{
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(5);
        taskExecutor.setMaxPoolSize(10);
        taskExecutor.setQueueCapacity(25);
        taskExecutor.initialize();
        return taskExecutor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }
}


   任務執行類：

package jack.ch3.taskexecutor;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

/**
 * Created by jack on 2017/7/15.
 */
@Service
public class AsyncTaskService {
    //通過@Async註解表明該方法是一個非同步方法，如果註解在類級別上，則表明該類所有的方法都是非同步方法，
    //而這裡的方法自動被注入使用ThreadPoolTaskExecutor作為TaskExecutor
    @Async
    public void executeAysncTask(Integer i){
        System.out.println("執行非同步任務："+i);
    }
    @Async
    public void executeAsyncTaskPlus(Integer i){
        System.out.println("執行非同步任務+1："+(i+1));
    }
}


    測試程式碼如下：

package jack.ch3.taskexecutor;

import jack.ch2.event.DemoPublisher;
import jack.ch2.event.EventConfig;
import jack.ch3.aware.AwareService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.scheduling.annotation.AsyncConfigurer;

/**
 * Created by jack on 2017/7/15.
 */
public class MainTest9 {
    public static void main(String [] args){
        //AnnotationConfigApplicationContext作為spring容器，接受一個配置類作為引數
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskExecutorConfig.class);
        AsyncTaskService asyncTaskService = context.getBean(AsyncTaskService.class);
        for (int i=0;i<10;i++){
            asyncTaskService.executeAysncTask(i);
            asyncTaskService.executeAsyncTaskPlus(i);
        }
        context.close();
    }
}


   執行程式，結果是併發的而不是順序執行的，如下：


三：計劃任務

    從spring3.1開始，計劃任務在spring中的實現變得異常的簡單，首先通過在配置類註解@EnableScheduling來開啟對計劃任務的支援，然後在要執行計劃任務的方法上註解@Scheduled，宣告這是一個計劃任務。

    spring通過@Scheduled支援多種型別的計劃任務，保護cron，fixDelay，fixRate等。

    示例如下：

    計劃任務執行類：

package jack.ch3.taskscheduler;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

/**
 * Created by jack on 2017/7/15.
 */
@Service
public class ScheduledTaskService {
    private static final SimpleDateFormat dateFormate = new SimpleDateFormat("HH:mm:ss");
    //通過@Scheduled宣告該方法是計劃任務，使用fixedRate屬性每隔固定時間執行
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime(){
        System.out.println("每隔五秒執行一次："+dateFormate.format(new Date()));
    }
    //使用cron屬性可按照指定時間執行，本例指定在11點25分執行；cron是UNIX和類UNIX（Linux）系統下的定時任務
    @Scheduled(cron = "0 25 11 ? * *")
    public void fixTimeExecutor(){
        System.out.println("在指定時間："+dateFormate.format(new Date())+" 執行");
    }
}


  計劃任務配置類：

package jack.ch3.taskscheduler;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * Created by jack on 2017/7/15.
 */
@Configuration
@ComponentScan("jack.ch3.taskscheduler")
@EnableScheduling   //通過@EnableScheduling 註解開啟對計劃任務的支援
public class TaskSchedulerConfig {
}


    測試程式碼：

package jack.ch3.taskscheduler;

import jack.ch3.taskexecutor.AsyncTaskService;
import jack.ch3.taskexecutor.TaskExecutorConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * Created by jack on 2017/7/15.
 */
public class MainTest10 {
    public static void main(String [] args){
        //AnnotationConfigApplicationContext作為spring容器，接受一個配置類作為引數
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskSchedulerConfig.class);

        //context.close();計劃任務這裡不能關閉，需要一直在後臺執行
    }
}


執行測試程式，結果如下：


    通過輸出結果可以看出，一個是每隔5秒執行的，一個是定時執行的。

四：條件註解@Conditional

        前面舉例了活動的profile，我們可以獲得不同的Bean。spring4提供了一個更通用的基於條件的bean的建立，即使用@Conditional註解

       @Conditional根據滿足某一個特定條件建立一個特定的Bean。比方說，當某一個jar包在一個類路徑下的時候，自動配置一個；或者只有某個bean被建立才會建立另外一個bean。總的來說，就是根據特定條件來控制bean的建立行為，這樣我們就可以利用這個特性進行一些自動化的配置。

       在spring boot中將會大量應用到條件註解。

       下面的示例將以不同的作業系統作為條件，我們將通過實行Condition介面，並重寫matches方法來構造判斷條件。若在Window系統下執行程式，則輸出列表命令dir；若在Linux系統下執行程式，則輸出列表命令ls。

      示例如下：

      判定Windows的條件：

package jack.ch3.conditional;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * Created by jack on 2017/7/15.
 */
//判斷Window的條件
public class WindowsConditional implements Condition{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return conditionContext.getEnvironment().getProperty("os.name").contains("Windows");
    }
}


判定Linux的條件：

package jack.ch3.conditional;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * Created by jack on 2017/7/15.
 */
//判斷Linux的條件
public class LinuxConditional implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return conditionContext.getEnvironment().getProperty("os.name").contains("Linux");
    }
}


   下面是一個介面：

package jack.ch3.conditional;

/**
 * Created by jack on 2017/7/15.
 * 介面
 */
public interface ListServer {
    public String showListCmd();
}


Windows下所要建立的Bean的類：

package jack.ch3.conditional;

/**
 * Created by jack on 2017/7/15.
 */
//Windows下所建立的Bean的類
public class WindowsListService implements ListServer {
    @Override
    public String showListCmd() {
        return "dir";
    }
}


Linux下所要建立的Bean類：

package jack.ch3.conditional;

/**
 * Created by jack on 2017/7/15.
 */
//Linux下所要建立的Bean類
public class LinuxListService implements ListServer {
    @Override
    public String showListCmd() {
        return "ls";
    }
}


  配置類：

package jack.ch3.conditional;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * Created by jack on 2017/7/15.
 */
@Configuration
public class ConditionConfig {
    /**
     * 通過@Conditional註解，符合Windows條件則例項化windowsListService
     * @return
     */
    @Bean
    @Conditional(WindowsConditional.class)
    public ListServer windowsListService(){
        return new WindowsListService();
    }

    /**
     * 通過@Conditional註解,符合Linux條件則例項化linuxListService
     * @return
     */
    @Bean
    @Conditional(LinuxConditional.class)
    public ListServer linuxListService(){
        return new LinuxListService();
    }
}


      測試程式碼如下：

package jack.ch3.conditional;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * Created by jack on 2017/7/15.
 */
@Configuration
public class ConditionConfig {
    /**
     * 通過@Conditional註解，符合Windows條件則例項化windowsListService
     * @return
     */
    @Bean
    @Conditional(WindowsConditional.class)
    public ListServer windowsListService(){
        return new WindowsListService();
    }

    /**
     * 通過@Conditional註解,符合Linux條件則例項化linuxListService
     * @return
     */
    @Bean
    @Conditional(LinuxConditional.class)
    public ListServer linuxListService(){
        return new LinuxListService();
    }
}


  執行結果如下：


相關推薦

Java多執行緒 ScheduledThreadPoolExecutor 計劃任務類的使用

                前面我們已經學習了使用ThreadPoolExecutor類來實現自動建立和執行執行緒。但是那些執

SpringBoot4-spring高階話題-spring aware，多執行緒，計劃任務，條件註解@Conditional

一：Spring Aware 1，點睛      spring的依賴注入的最大亮點就是你所有的Bean對Spring容器的存在是沒有意識的，即你可以將你的容器替換成別的容器，如Google Guice，這時Bean之間的耦合度很低。     但是在實際專案中，你不可避免的要

Spring在多執行緒的情況下，如何控制事務起作用

因為執行緒不屬於spring託管，故執行緒不能夠預設使用spring的事務,也不能獲取spring注入的bean在被spring宣告式事務管理的方法內開啟多執行緒，多執行緒內的方法不被事務控制。如下程式碼，執行緒內呼叫insert方法，spring不會把insert方法加入事

spring+ActiveMQ+JMS+執行緒池實現簡單的分散式，多執行緒，多工的非同步任務處理系統

前言：隨著系統的業務功能不斷增強，傳統的單機、單任務，單執行緒的執行模式已經逐漸的被淘汰，取而代之的是分散式，多工，多執行緒，當然，現在開源的這方面的框架也非常的多，大概的思想也都類似，下面就結合我這一年多的工作心得，分享一個簡單易實現的分散式，多工，多執行緒的非同步任務處理系統的基本實現。 1.系統部署圖

Spring Boot教程十五：多執行緒

實際的開發應該開發過程中，經常需要使用到多執行緒，而且大多時候需要獲取到每個執行緒執行的結果，然後再執行剩下的業務邏輯。具體實現如下； pom檔案引用： <dependency> <groupId>com.go

spring-boot | 多執行緒併發定時任務

剛剛看了下Spring Boot實現定時任務的文章，感覺還不錯。Spring Boot 使用Spring自帶的Schedule來實現定時任務變得非常簡單和方便。在這裡個大家分享下。 開啟快取註解 @SpringBootApplication @EnableScheduling //開啟定

Linux程式設計 多程序，多執行緒求解PI（圓周率）

題目： 連結 多程序： #include <unistd.h> #include <stdio.h> #include <stdlib.h> #define n 100000000.0 int main() { i

單執行緒的弊端，多執行緒基礎學習

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using

libcurl，多執行緒，gzip，共享DNS

http://hi.baidu.com/jjxiaoyan/item/e17b9ec3e31b93d4964452d8   libcurl是一個不錯的socket庫，而且又是開源的。如果僅僅是簡單的HTTP請求，那麼只需要幾行程式碼就能輕鬆實現。不過要用libcurl實現高效、高頻率的HTTP請

學習彙集地，如果你擅長計算機組成原理，多執行緒，設計模式，jvm，前端或者其他都可以

擅長jvm 多執行緒 設計模式 資料庫 前端 分散式什麼的一起學習共同進步。   目的是大家在自學新的領域的時候有地方可以探討求疑 比如在看到垃圾回收各種收集器中遇到執行緒方面知識的時候 學習設計模式分不清單例和享元的區別，只有書本經驗不知道如何應用到實際開發的時候 學習資料庫系統

Qt TCP通訊，多執行緒伺服器端

相信許多初學Qt的同學都會和我一樣遇到這樣的問題： 一、Qt TCP通訊在使用nextPendingConnect後，伺服器端就只會與最後接入的客戶端通訊，這個時候就會考慮繼承QThread實現多執行緒，從而實現多個客戶端與伺服器端通訊，每當一個新的客戶端連線時，通過標識碼socke

利用itertools生成密碼字典，多執行緒撞庫破解rar壓縮檔案密碼

指令碼功能：　　利用itertools生成密碼字典（迭代器形式）　　多執行緒併發從密碼字典中取出密碼進行驗證　　驗證成功後把密碼寫入檔案中儲存 #!/usr/bin/env python # -*- coding: UTF-8 -*- # Author:Leslie-x import itert

多執行緒縣互動例項，生產消費

生產者消費者問題是一個非常典型性的執行緒互動的問題。 1. 使用棧來存放資料 1.1 把棧改造為支援執行緒安全 1.2 把棧的邊界操作進行處理，當棧裡的資料是0的時候，訪問pull的執行緒就會等待。 當棧裡的資料時200的時候，訪問push的執行緒就會等待 2. 提供一個生產者（Producer）執

FMDB使用，事務，多執行緒，加密等比較全面的用法。

一：簡單使用 既然FMBD是對資料庫的封裝，那基本功能應該包括 增、刪、改、查。 主要使用到的類為FMDatabase（資料庫）FMResultSet（查詢的結果）。 其中增、刪、改，三個方法都是使用FMDatabase類的executeUpdate方法也就是都算作資料的更新， 而查

多執行緒--生產者消費者範例，使用lock和condition

        上一篇的部落格已經介紹了生產者和消費者，最後還是遺留了一個問題，就是必須Notifyall才能保證喚醒對方執行緒，這樣降低了效率，那麼，有沒有什麼辦法可以指定我們來喚醒哪一個執行緒呢？   &

c++單例模式，多執行緒使用

c++ 11保證了這樣做是執行緒安全的。 一:class Singleton{ static Singleton* GetInstance(){         static Singleton s;     

多程序，多執行緒

一個程序可以多執行緒，但是多執行緒就像是十字路，一個執行緒掛了，如果對多執行緒的共享堆、全域性變數等非棧記憶體造成了影響，那麼它所屬的程序就掛了。 而多程序則像是立交橋，互不想幹。一個程序掛了不會導致整個程式崩潰。所以在想要保證 程式的可用性（不會動不動就堵塞）是可以使用多程序，也可以保證主程序的穩定，比

自己實戰整理面試題--多執行緒（帶答案，不斷更新）

一個執行緒兩次呼叫 start() 方法會出現什麼情況？執行緒的生命週期，狀態是如何轉移的？ Java 的執行緒是不允許啟動兩次的，第二次呼叫必然會丟擲 IllegalThreadStateException，這是一種執行時異常，多次呼叫 start 被認為是程式設計錯誤。 關於執行緒生

Java——多執行緒基本使用（三） 餓漢式和懶漢式的單例設計模式，多執行緒之間的通訊

這一則部落格主要寫的是單例設計模式，與實現多執行緒之間的通訊等等~ 1.單例設計模式：保證類在記憶體中只有一個物件 2.保證類在記憶體中只有一個物件            &

Python高階程式設計（四）多執行緒

Python 多執行緒 多執行緒類似於同時執行多個不同程式，多執行緒執行有如下優點： 使用執行緒可以把佔據長時間的程式中的任務放到後臺去處理。 使用者介面可以更加吸引人，這樣比如使用者點選了一個按鈕去觸發某些事件的處理，可以彈出一個進度條來顯示處理的進度 程式的執