作者：追夢1819
原文：https://www.cnblogs.com/yanfei1819/p/11076555.html
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

引言

  相信大家對定時任務很熟悉，其重要性也不言而喻。定時發短信、定時批量操作、定時統計數據等，都離不開定時任務。本文將講解定時任務在 SpringBoot 項目中的應用。

版本信息

• JDK：1.8
• SpringBoot ：2.0.1.RELEASE
• maven：3.3.9
• IDEA：2019.1.1
• quartz：2.3.0

定時任務實現方式

JDK自帶的Timer

  Timer 是Java 自帶的定時任務類。可以用作比較簡單的定時任務。通常用的不多。下面以一個小的示例展示其用法。

SpringBoot集成的schedule

這種方式是 SpringBoot 集成的，使用很簡單。

首先，引入 SpringBoot 的基礎 jar：

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>

然後再啟動類中添加註解 @EnableScheduling 即可開啟 SpringBoot 定時任務：

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

下面根據 @Scheduled 的不同屬性創建幾個任務：

任務一：

@Component
public class FirstTask {
    /**
     * cron 表達式
     */
//    @Scheduled(cron = "0/2 * * * * *")
    @Scheduled(cron="${cron.schedule}")
    public void run(){
        System.out.println("這是創建的第一個定時任務");
    }
}

作幾點說明：

1. cron 表達式是 @Scheduled 的屬性之一，其值可以直接設置為 cron 表達式；
2. @Scheduled(cron="${cron.schedule}") 是動態讀取 application.properties 配置文件中的 cron 表達式。例如項目中的一個需求是每天凌晨0點執行，但是對於測試人員來說，不可能等到凌晨測試。動態讀取可以幫助解決該問題。

任務二：

@Component
public class SecondTask {
    /**
     * 上一次執行完畢時間點之後多長時間再執行(ms)
     */
    @Scheduled(fixedDelay = 2000)
    public void run(){
        System.out.println("這是創建的第二個定時任務");
    }
}

任務三：

@Component
public class ThirdTask {
    /**
     * 與fixedDelay功能相同，上一次執行完畢時間點之後多長時間再執行(ms)，區別是：1、時間是字符串；2、支持佔位符
     */
    // @Scheduled(fixedDelayString = "2000")
    @Scheduled(fixedDelayString = "${time.fixedDelay}")
    public void run(){
        System.out.println("這是創建的第三個定時任務");
    }
}

上面的三個任務列舉了 @Scheduled 註解的三個參數。其實除此之外，查看 @Scheduled 的源碼可知，還有其餘的幾個參數：

• fixedRate：上一次開始執行時間點之後多長時間再執行；
• fixedRateString：上一次開始執行時間點之後多長時間再執行；
• fixedRateString：與fixedRate 意思相同，只是使用字符串的形式。唯一不同的是支持佔位符；
• initialDelay：第一次延遲多長時間后再執行；
• initialDelayString：與 initialDelay 意思相同，只是使用字符串的形式。唯一不同的是支持佔位符；

整合Quartz

  如果以上的方式都無法滿足項目的需求，則可以試試 Quartz 調度框架。它功能的強大以及使用無需多說了。此處我們看看 Quartz 在 SpringBoot 中的使用。

創建項目，引入 Quartz 調度框架啟動器：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

  需要注意版本信息，如果 SpringBoot 版本是2.0以後的版本，直接引入 Quartz 啟動器即可。但是如果是2.0以前的版本，需要引入以下 jar 包：

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>

下面創建任務了：

public class QuartzTask extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(new Date());
    }
}

任務需要繼承 QuartzJobBean 抽象類，並重寫 executeInternal 方法。

第三步，創建 quartz 配置類，添加 @Configuration 註解：

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail testQuartzTask() {
        return JobBuilder.newJob(QuartzTask.class).withIdentity("quartztask").storeDurably().build();
    }
    @Bean
    public Trigger testQuartzTrigger2() {
        //cron方式，每隔5秒執行一次
        return TriggerBuilder.newTrigger().forJob(testQuartzTask())
                .withIdentity("quartztask")
                .withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?"))
                .build();
    }
}

  上面的示例是使用 cron 表達式，當然也可以是固定時間間隔。本節是闡述 SpringBoot 和 Quartz 的整合，不作 Quartz 的詳細使用。感興趣的讀者可以登錄 Quartz 的官網 或者中文官網自行研究。

總結

  定時任務的實現方式有很多種，除了上面說到的幾種方式，還有利用線程池實現定時任務，有的系統是通過 Liunx 實現定時任務。總之，定時任務的實現方式多種多樣，其方式要根據項目的實際情況而選。切不可為了實現而實現。

【精選推薦文章】

智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置，台北網頁設計，各種案例分享

廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

IScroll中文文檔

第一個問題： 邊界留白

　　就是這種，上邊界（最小），下邊界（最大）有兩個列表的位置是不能選擇的。解決的辦法是：

　　在HTML中，添加空白節點就行了。

第二個問題：初始化之後的滾動停止的事件的第二個參數問題。　　

var myScroll = new IScroll('#wrapper');
myScroll.on('scrollEnd', function(){
    //這裏一定不要寫成es6箭頭函數
    //要執行的代碼
    //這個函數沒有參數
});

（1） 第二的個參數，是個函數。它沒有參數，而且不要寫成，不要寫成，不要寫成箭頭的形式。因為這函數裏面的this，是綁定的一些有用信息，比如：this.y是當前滾動的距離等。還有哪些信息可以看 文檔中的 滾動條信息 這一欄。如果寫成ES6的形式，那this指向就變了，這樣就獲取不了所需的信息。

（2） 第二個參數是沒有形參的。即沒有任何可使用的參數。

第三個問題：定義了snap選項，但是滾動有偏差

　　開發的日曆選擇組件picker是使用rem單位自適應的，雖然在配置項中 有個options.snap，官方說可以對齊到固定的位置和元素，但是在使用自適應單位的情況中，這個配置並沒有展現出真正的效果，滾動的時候一定會出現偏差。

　　那怎麼解決這個自適應的問題呢？由於是在滾動結束之後，位置才出現的偏差。那麼我就在滾動結束之後立馬調用修正位置的函數就行了。

　　我是在vue中使用的。所以定義下面的函數，因為有 年，月，日，時四個滾動項。所以需要判斷是哪一個正在滾動

fixPos: function(target,num) {
    var step = Math.abs(Math.round(target.y / this.itemHeight));
    var maxYearLen = this.yearArr.length;
    var maxMonthLen = this.monthArr.length;
    var maxDayLen = this.dayArr.length;
    var maxHourLen = this.hourArr.length;
    switch(num){
        case 0:
            step = step > maxYearLen ? maxYearLen - 1 : step;
            break;
        case 1:
            step = step > maxMonthLen ? maxMonthLen - 1 : step;
            break;
        case 2:
            step = step > maxDayLen ? maxDayLen - 1 : step;
            break;
        case 3:
            step = step > maxHourLen ? maxHourLen - 1 : step;
            break;
    }
    var fixPos = step * this.itemHeight;//重新計算較為精確的位置
    target.y = fixPos;//重置原來的滾動距離 this.selectArr[num] = step;//這是保存每個列表滾動的索引值
    target.scrollTo(0, -fixPos);//這是滾動到修正後的位置
},

（1） 大致的思路就是：首先用當前滾動的距離，來除以滾動內容中，每個列表的高度。然後取最近似的值，就是當前應該滾動的列表的個數。

（2） 如果出現突然滾動到最底部，這時候需要滾動的個數大於了滾動內容的最大列表個數，那麼就糾正一下個數為最大列表數 – 1。

（3） 然後設置較為精確的滾動距離。再滾動到指定的位置。

（4） this.itemHeight是在created生命周期的時候就聲明的 this.itemHeight = (document.body.offsetWidth / 750) * 100 * 0.8;  相當於在375px寬度下，每個列表就是40px的高度。在iPhone5 320px下，就是34.133334了。

　　調用的時候：　

var yearScroll = new IScroll('#calendarYear');
var that = this;
yearScroll.on('scrollEnd', function() {
    that.fixPos(this, 0);
})

第四個問題：使用自適應單位時最大滾動距離不準確

　　這個問題和第二個問題類似，解決的方法：

fixMaxScrollY: function(target, num) {
    var yearLen = this.yearArr.length - 1;
    var monthLen = this.monthArr.length - 1;
    var dayLen = this.dayArr.length - 1;
    var hourLen = this.hourArr.length - 1;
    switch(num) {
        case 0:
            target.maxScrollY = -(Math.round(yearLen * this.itemHeight));
            break;
        case 1:
            target.maxScrollY = -(Math.round(monthLen * this.itemHeight));
            break;
        case 2:
            target.maxScrollY = -(Math.round(dayLen * this.itemHeight));
            break;
        case 3:
            target.maxScrollY = -(Math.round(hourLen * this.itemHeight));
            break;
    }
},

（1）  實例化后的滾動對象，有個最大滾動值maxScrollY，主要也是根據滾動內容的列表長度來重置最大滾動距離

（2）  因為有四個滾動的內容項，所以需要傳入當前是第幾個滾動的內容。

　　調用的時候：

var yearScroll = new IScroll('#calendarYear');
this.fixMaxScrollY(yearScroll, 0);

第五個問題： 日曆組件的內容是在點擊某個按鈕之後再觸發显示的，最初是隱藏。但就是這個原因，導致显示出來的內容滾動不了。

　　解決的辦法是：使用 xxx.refresh() 刷新函數。這個函數具體的說明可以看文檔中 刷新 這個選項內容

　　在控制組件显示的函數中，調用刷新的方法。

this.$nextTick(function(){
    this.scrollTarget[0].refresh();
    this.scrollTarget[1].refresh();
    this.scrollTarget[2].refresh();
    this.scrollTarget[3].refresh();
    //如果默認隱藏，則必須修復滾動的位置
    this.scrollTarget[0].scrollTo(0, -this.itemHeight * this.selectArr[0]);
    this.scrollTarget[1].scrollTo(0, -this.itemHeight * this.selectArr[1]);
    this.scrollTarget[2].scrollTo(0, -this.itemHeight * this.selectArr[2]);
    this.scrollTarget[3].scrollTo(0, -this.itemHeight * this.selectArr[3]);
})

（1） scrollTarget 是初始化滾動實例之後，保存的滾動實例。因為多次會用到。

（2） 因為有年，月，日，時四個滾動內容，所以要刷新四個滾動器。

（3） 如果日曆有最初的滾動位置，那麼也會出現不能跳到指定的位置的問題。所以，也需要初始化最初始的位置。

（4） selectArr 是滾動器滾動的索引值。比如我月份是1月到12月，當前滾動到了6月，那麼此時selectArr[1] 就是5 。

（5） 官方是推薦用setTimeout來使用刷新，但是我使用的是vue來開發的，所以，這裏用vm.$nextTick（）來代替setTimeout。

第六個問題： 日曆組件復用時，只能初始化滾動第一個日曆組件，而且第一個日曆組件滾動還是有問題。

　　這個問題產生的原因很簡單：因為 IScroll 在初始化實例的時候， var myScroll = new IScroll(‘.wrapper’);  它這個css選擇器使用的是querySelector 而不是 querySelectorAll，所以iScroll只會作用到選擇器選中元素的第一個。如果你需要對多個對象使用iScroll，你需要構建自己的循環機制。這是官方的說法。那麼怎樣建立循環機制呢？難道我要在初始化的時候還要循環去 new IScroll（xxx）創建實例嗎？

　　其實沒必要。只需要改一改源碼就行了。

　　我使用的是 iscroll-lite 這個版本。這裏面 在定義 IScroll 這個函數的時候有這段代碼

this.wrapper = typeof el == 'string' ? document.querySelector(el) : el;

　　它每次初始化時，只選擇了 el  滾動對象的第一個元素，那麼，我只需要傳入當前是第幾個日曆組件，再改成querySelectorAll就行了。即：

this.wrapper = typeof el == 'string' ? document.querySelectorAll(el)[childIndex] : el;

　　然後在這個定義的 IScroll 函數的參數中，再增加一個參數，表示第幾個元素。

　　然後在初始化滾動實例的時候：

var options = {
    snap: '.calendar-scroll-item', //對齊的位置，相當於自動糾正每次移動的距離
    //scrollbars: true,//是否显示滾動條
}
//初始化滾動
var yearScroll = new IScroll('.calendar-scroll>.calendarYear', options , this.curIndex);

　　當然這個時候，css選擇器就不要用 id 了。

　　然後在 組件的 prop 裏面添加一個屬性。

curIndex:{
    type:Number,
    default:0
}

（1） 默認只使用一個組件，即不傳這個prop 的話就是默認初始化第一個組件的滾動內容。

　　使用組件的時候：引入，註冊等步驟就省略了

<calendar :cur-index='0'/>
<calendar :cur-index='1'/>
<calendar :cur-index='2'/>

 　　這樣不管使用多少個，都能正常初始化滾動了。而且互不影響 。注意，如果傳的是数字，需要v-bind 告訴vue這不是字符串，是表達式。不然傳過去的是字符串

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

簡介

 　　環境搭建好了，其他方面的知識也準備的差不多了，那麼我們就開始下一步元素定位，元素定位宏哥主要介紹如何使用uiautomatorviewer，通過定位到頁面上的元素，然後進行相應的點擊等操作. 此外在介紹另一款工具：Inspector。

uiautomatorviewer是android-sdk自帶的一個元素定位工具，非常簡單好用，使用uiautomatorviewer，你可以檢查一個應用的UI來查看應用的布局和組件以及相關的屬性。

　　那麼宏哥先來給各位小夥伴們介紹大哥–uiautomatorviewer，再來介紹小弟–Inspector。

一、大哥–uiautomatorviewer

　　大哥人物簡介：

　　大哥是皇族後裔，但是比劉皇叔強多了。人家有一個好爹–Google。

　　Android 4.1發布的，uiautomator是用來做UI測試的。也就是普通的手工測試，點擊每個控件元素 看看輸出的結果是否符合預期。比如 登陸界面 分別輸入正確和錯誤的用戶名密碼然後點擊登陸按鈕看看是否能否登陸以及是否有錯誤提示等。

功能性或者黑盒UI測試不需要測試人員了解程序如何實現的，只需要驗證各種操作的結果是否符合預期即可。這樣的測試可以分離團隊的開發人員和測試人員。大家各干各的沒有太多的交集。

　　常用的UI測試方式就是人工驗證啦，就是測試人員拿着各種手機分別安裝要測試的程序然後看看是否能正確完成各種預定的功能。但是這種驗證方式是非常耗時間的，每次回歸都要全部驗證一邊，並且還容易出現人為錯誤。比較高效和可靠的UI測試方式就是自動化測試。自動化UI測試創建測試代碼來執行測試任務，各種測試任務分別覆蓋不同的使用場景，然後使用測試框架來運行這些測試任務。而uiautomator 就是你的自動化UI測試工具。

Android SDK在4.1中提供了如下工具來支持UI自動化測試：

• uiautomatorviewer – 一個圖形界面工具來掃描和分析應用的UI控件。
• uiautomator – 一個測試的Java庫，包含了創建UI測試的各種API和執行自動化測試的引擎。

要大哥出山也就是使用該工具，需要滿足如下條件：

• Android SDK Tools, Revision 21 or higher
• Android SDK Platform, API 16 or higher

一、啟動uiautomatorviewer.bat

兩種啟動方法：

第一種方法：

1、打開目錄D:\software\android-sdk-windows\tools

2、雙擊啟動，啟動之後出現如下界面

 
第二種方法：

1、如果不喜歡雙擊啟動的話，也可以在cmd裏面通過指令啟動

先cd到tools目錄下，然後輸入uiautomatorviewer.bat回車后啟動服務

二、連接手機

1、cmd打開輸入adb devices,確認手機已連上（以夜神模擬器為例）

2、打開手機淘寶頁面，讓屏幕處於點亮狀態

3、點左上角安卓機器人按鈕Devices Screenshot按鈕刷新頁面

三、定位元素

1、移動鼠標到需要定位的元素上，如搜索輸入框

2、右下角可以看到元素對應的屬性

text:好沙發需要好坐墊

resource-id:com.taobao.taobao:id/home_searchedit

class:android.widget.EditText

四、點搜索框

1、前面一篇啟動app后，休眠五秒，等待頁面加載完成

2、通過id來定位到搜索框，然後點擊

五、參考代碼

# coding=utf-8
# 1.先設置編碼，utf-8可支持中英文，如上，一般放在第一行

# 2.註釋：包括記錄創建時間，創建人，項目名稱。
'''
Created on 2019-6-24
@author: 北京-宏哥   QQ交流群：707699217
Project:學習和使用定位元素工具
'''
# 3.導入模塊
from appium import webdriver
import time
desired_caps = {}
desired_caps['platformName'] = 'Android'   #android的apk還是IOS的ipa
desired_caps['platformVersion'] = '8.0'  #android系統的版本號
desired_caps['deviceName'] = '127.0.0.1:62001'    #手機設備名稱，通過adb devices  查看
desired_caps['appPackage'] = 'com.taobao.taobao'  #apk的包名
desired_caps['appActivity'] = 'com.taobao.tao.welcome.Welcome'  #apk的launcherActivity
#desired_caps['unicodeKeyboard'] = True   #使用unicodeKeyboard的編碼方式來發送字符串
#desired_caps['resetKeyboard'] = True   #將鍵盤給隱藏起來
driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps) #啟動服務器地址，後面跟的是手機信息
# 休眠五秒等待頁面加載完成
time.sleep(5)

driver.find_element_by_id("com.taobao.taobao:id/home_searchedit").click()

# driver.quit()

六、元素定位

1、appium的webdriver提供了11種元素定位方法，在selenium的基礎上擴展了三個，可以在pycharm裏面輸入driver.find_element_by然後會自動匹配出來

2、多的三種如下，在後面的會詳細介紹

driver.find_element_by_accessibility_id()

driver.find_element_by_android_uiautomator()

driver.find_element_by_ios_uiautomation()

（第三個是ios的可以暫時不用管）

二、小弟–Inspector

 　　小弟人物簡介：

　　小弟不是很牛叉，但是小弟的存在必定有小弟存在的必要，之前看了好多文章都要放棄小弟，我覺地不要放棄，沒準小弟可以替大哥大哥擋刀呢，呵呵，說笑了，畢竟過河的卒子可以當車！！！

　　Appium Inspector是appium自帶的一個元素定位工具，前邊介紹了如何使用uiautomatorviewer進行元素定位。這裏就學習Appium Inspector是如何定位的。

　　Appium Inspector 對於測試的同學不得不說是一個神器，可以查詢到我們需要定位的元素的 id 等各種信息 ，還可以 錄製用戶行為，翻譯成腳本。逆天的是可以翻譯成多種語言的腳本。這並不意味着測試的同學可以不用學習語言和編程了，因為機器翻譯出的腳本一般很難一次執行成功，其中很可能還需要經過人工修改后才能順利執行，但是這已經可以為測試腳本的編寫帶來很大的遍歷，所以 Appium Inspector 還是值得我們去學習和使用。

一、設置appium

1、先不要啟動appium，因為啟動以後就不能操作appium設置界面，必須在未啟動的時候進行操作

2、點開android setting界面（機器人圖標）

3、勾選Application Path,添加被測app的路徑

4、Devices name處添加設備名稱（adb devices查看到的）

（注意：通過這種方法也可查看到apk的包名和Launch Activity）

二、開啟appium

1、手機確保連接電腦（adb devices查看）（仍然以夜神模擬器為例）

2、點appium右上角三角形圖標，會啟動服務

3、這時候可以看到手機上安裝淘寶應用，並會啟動淘寶

4、點appium右上角的搜索圖標

5、點Inspector Window界面的 Refresh 按鈕刷新界面

三、Ispector Window

1、手機上打開需要單位元素的界面，然後點Refresh按鈕刷新

2、左邊菜單樹，可以挨個點開

3、如果想單位界面上的“是”和“否”按鈕，從菜單樹就可以看到這兩個元素的結構

四、查看屬性

1、選中左側菜單樹對應的元素，在右下角查看對應屬性

五、常見異常

1、在使用過程中，你會發現經常會報以下這個錯誤

2、每次啟動都會給你手機上重新安裝一次應用

3、並且不能用鼠標指定某個元素，沒有uiautomatorviewer使用方便

（要是以上三種問題你都遇到了，怎麼辦？？？那就放棄吧！！！）​

相信很多人在使用過程中，都會遇到中文無法輸入問題，宏哥在後續文章里會手把手教大家如何輸入中文。

三、小結

Android SDK中的UIAutomator中本身是不支持網頁中的UI元素定位，下面介紹幾種常用的定位app內部的網頁的UI元素的方法。

一、使用chrome瀏覽器調試移動端網頁

       這是使用最多的一種方法。首頁確保自己的手機已經跟電腦連接且處於開發者模式。

       打開PC端的谷歌瀏覽器，輸入chrome://inspect/#devices，會看到下圖所示界面：

     點擊需要測試的網頁下方的inspect，且保證手機界面停留在那個頁面。

      這樣打開后是不是就熟悉了，點擊上方紅色標記的就可以操作進行定位了~~~

 二、Android手機的鋪助功能帶有TalkBack

        之前一直用的是谷歌的方法，但是最近發現使用talkback可以直接用UIAutomator定位元素。  

        Android系統一般自帶一個TalkeBack功能。但這裏千萬要注意：打開之後整個系統的操作都變得不同了！！滑動界面需要兩個手指，單擊變成雙擊。打開之後用UiAutomatorViewer獲取webview界面的內容，你就會發現原來webview裏面獲取不到的ui元素，現在已經可以可以獲取到了。即使現在你關掉TalkBack，也能獲取到，除非重啟手機才會回到不能獲取的狀態，所以開啟后我們可以立即關閉，以方便操作。有些手機沒有talkBack的可以去應用市場下載。

       功能路徑：
       原生系統：設置 – 輔助功能(Accessibility) – TalkBack
       華為EMUI系統：設置 – 高級設置 – 輔助功能 – TalkBack

三、宏哥在小弟哪裡遇到的問題

查看appium日誌的error發現沒有設備名字報錯

將夜神模擬器的名字加上就成功了

宏哥不能保證所整理都符合大家的口味，但我能保證每一篇都是用心去寫和用心去整理，我始終認同“分享的越多，你的價值增值越大”，歡迎大家關注我的博客和個人公眾號的技術分享。在分享中進步，越努力越幸運，期待我們都有美好的明天！

支持宏哥的朋友們和宏哥的宏粉記得點波推薦哦，您的肯定就是我進步的動力。鄙人先在這裏給您道謝了，謝您嘞~~

個人公眾號（因為許多文章都被搬到別人的公眾號里了，還是原創，所以宏哥果斷也開一個公眾號。打算與博客園文章同步，希望大家隨時隨地學習與進步）：

微信群（因為有人給我發短消息說公司不讓用QQ，就幫忙建立一個微信群，歡迎加入討論和交流）

我的博客即將同步至騰訊雲+社區，邀請大家一同入駐：https://cloud.tencent.com/developer/support-plan?invite_code=2k3h2stkvscgc

【精選推薦文章】

智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置，台北網頁設計，各種案例分享

廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

     最近做項目，使用的是echarts显示圖表數據，但是數據量比較多的時候，有卡頓的情況。後來同事拿echarts和HighCharts做了對比，僅供大家參考。同時感謝同事做的工作。

一、查詢1天的源數據，屬性1、屬性2、屬性3、屬性4

       Echarts查詢3.61s，渲染0.786s（約8.6M數據）

       HighCharts查詢3.10s，渲染0.768s（約8.7M數據）

二、查詢7天的源數據，屬性1、屬性2、屬性3、屬性4

      Echarts查詢21.67秒，渲染5.38秒。（約60.7M數據）。渲染完成后

      HighCharts查詢22.18s，渲染5.39s。（約60.5M數據）

三、查詢14天的源數據，屬性1、屬性2、屬性3、屬性4

      Echarts渲染不出來，瀏覽器崩潰。

      HighCharts查詢41.42s，渲染10.82s。（約121M數據）

四、內存佔用對比：7天數據

      Echarts渲染后瀏覽器佔用內存約3280M。

      HighCharts渲染后瀏覽器佔用內存約637M。

五、操作對比

雲端操作系統：http://www.ineuos.net

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

SpringBoot系列文章簡介

SpringBoot源碼閱讀輔助篇：

　　Spring IoC容器與應用上下文的設計與實現

SpringBoot啟動流程源碼分析：

1. SpringBoot啟動流程分析（一）：SpringApplication類初始化過程
2. SpringBoot啟動流程分析（二）：SpringApplication的run方法
3. SpringBoot啟動流程分析（三）：SpringApplication的run方法之prepareContext()方法
4. SpringBoot啟動流程分析（四）：IoC容器的初始化過程
5. SpringBoot啟動流程分析（五）：SpringBoot自動裝配原理實現
6. SpringBoot啟動流程分析（六）：IoC容器依賴注入

筆者註釋版Spring Framework與SpringBoot源碼git傳送門：請不要吝嗇小星星

1. spring-framework-5.0.8.RELEASE
2. SpringBoot-2.0.4.RELEASE

一、前言

　　前一篇博客介紹了 SpringApplication 類的實例化過程，本章總結SpringBoot啟動流程最重要的部分run方法。通過rrun方法梳理出SpringBoot啟動的流程，然後後面的博客再一步步的分析啟動流程中各個步驟所做的具體的工作。深入分析後會發現SpringBoot也就是給Spring包了一層皮，事先替我們準備好Spring所需要的環境及一些基礎，具體通過源碼一步步深入分析後會發現Spring是真的很偉大。當然跟代碼的時候越深入越容易陷進去進而發現有些東西沒法通過博客詳細的梳理出來。當然在這個過程中還是立足於我們對SpringBoot的使用來說明源碼所做的工作。知其然才能知其所以然。加油

二、SpringBoot啟動流程梳理

　　首先擺上run方法的源碼

 1 /**
 2  * Run the Spring application, creating and refreshing a new
 3  * {@link ApplicationContext}.
 4  *
 5  * @param args the application arguments (usually passed from a Java main method)
 6  * @return a running {@link ApplicationContext}
 7  *
 8  * 運行spring應用，並刷新一個新的 ApplicationContext（Spring的上下文）
 9  * ConfigurableApplicationContext 是 ApplicationContext 接口的子接口。在 ApplicationContext
10  * 基礎上增加了配置上下文的工具。 ConfigurableApplicationContext是容器的高級接口
11  */
12 public ConfigurableApplicationContext run(String... args) {
13     //記錄程序運行時間
14     StopWatch stopWatch = new StopWatch();
15     stopWatch.start();
16     // ConfigurableApplicationContext Spring 的上下文
17     ConfigurableApplicationContext context = null;
18     Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
19     configureHeadlessProperty();
20     //從META-INF/spring.factories中獲取監聽器
21     //1、獲取並啟動監聽器
22     SpringApplicationRunListeners listeners = getRunListeners(args);
23     listeners.starting();
24     try {
25         ApplicationArguments applicationArguments = new DefaultApplicationArguments(
26                 args);
27         //2、構造應用上下文環境
28         ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
29         //處理需要忽略的Bean
30         configureIgnoreBeanInfo(environment);
31         //打印banner
32         Banner printedBanner = printBanner(environment);
33         ///3、初始化應用上下文
34         context = createApplicationContext();
35         //實例化SpringBootExceptionReporter.class，用來支持報告關於啟動的錯誤
36         exceptionReporters = getSpringFactoriesInstances(
37                 SpringBootExceptionReporter.class,
38                 new Class[]{ConfigurableApplicationContext.class}, context);
39         //4、刷新應用上下文前的準備階段
40         prepareContext(context, environment, listeners, applicationArguments, printedBanner);
41         //5、刷新應用上下文
42         refreshContext(context);
43         //刷新應用上下文後的擴展接口
44         afterRefresh(context, applicationArguments);
45         //時間記錄停止
46         stopWatch.stop();
47         if (this.logStartupInfo) {
48             new StartupInfoLogger(this.mainApplicationClass)
49                     .logStarted(getApplicationLog(), stopWatch);
50         }
51         //發布容器啟動完成事件
52         listeners.started(context);
53         callRunners(context, applicationArguments);
54     } catch (Throwable ex) {
55         handleRunFailure(context, ex, exceptionReporters, listeners);
56         throw new IllegalStateException(ex);
57     }
58 
59     try {
60         listeners.running(context);
61     } catch (Throwable ex) {
62         handleRunFailure(context, ex, exceptionReporters, null);
63         throw new IllegalStateException(ex);
64     }
65     return context;
66 }

　　具體的每一行代碼的含義請看註釋，我們在這先總結一下啟動過程中的重要步驟：（筆者傾向於將應用上下文同容器區分開來）

第一步：獲取並啟動監聽器
第二步：構造應用上下文環境
第三步：初始化應用上下文
第四步：刷新應用上下文前的準備階段
第五步：刷新應用上下文
第六步：刷新應用上下文後的擴展接口

　　OK，下面SpringBoot的啟動流程分析，我們就根據這6大步驟進行詳細解讀。最總要的是第四，五步。我們會着重的分析。

三、第一步：獲取並啟動監聽器

　　事件機制在Spring是很重要的一部分內容，通過事件機制我們可以監聽Spring容器中正在發生的一些事件，同樣也可以自定義監聽事件。Spring的事件為Bean和Bean之間的消息傳遞提供支持。當一個對象處理完某種任務后，通知另外的對象進行某些處理，常用的場景有進行某些操作后發送通知，消息、郵件等情況。

1 private SpringApplicationRunListeners getRunListeners(String[] args) {
2     Class<?>[] types = new Class<?>[]{SpringApplication.class, String[].class};
3     return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
4             SpringApplicationRunListener.class, types, this, args));
5 }

　　在這裏面是不是看到一個熟悉的方法：getSpringFactoriesInstances()，可以看下下面的註釋，前面的博文我們已經詳細介紹過該方法是怎麼一步步的獲取到META-INF/spring.factories中的指定的key的value，獲取到以後怎麼實例化類的。

 1 /**
 2  * 通過指定的classloader 從META-INF/spring.factories獲取指定的Spring的工廠實例
 3  * @param type
 4  * @param parameterTypes
 5  * @param args
 6  * @param <T>
 7  * @return
 8  */
 9 private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
10                                                       Class<?>[] parameterTypes, Object... args) {
11     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
12     // Use names and ensure unique to protect against duplicates
13     //通過指定的classLoader從 META-INF/spring.factories 的資源文件中，
14     //讀取 key 為 type.getName() 的 value
15     Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
16     //創建Spring工廠實例
17     List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
18             classLoader, args, names);
19     //對Spring工廠實例排序（org.springframework.core.annotation.Order註解指定的順序）
20     AnnotationAwareOrderComparator.sort(instances);
21     return instances;
22 }

 　　回到refresh方法，debug這個代碼 SpringApplicationRunListeners listeners = getRunListeners(args); 看一下獲取的是哪個監聽器：

　　EventPublishingRunListener監聽器是Spring容器的啟動監聽器。

　　 listeners.starting(); 開啟了監聽事件。

四、第二步：構造應用上下文環境

　　應用上下文環境包括什麼呢？包括計算機的環境，Java環境，Spring的運行環境，Spring項目的配置（在SpringBoot中就是那個熟悉的application.properties/yml）等等。

　　首先看一下prepareEnvironment()方法。

 1 private ConfigurableEnvironment prepareEnvironment(
 2         SpringApplicationRunListeners listeners,
 3         ApplicationArguments applicationArguments) {
 4     // Create and configure the environment
 5     //創建並配置相應的環境
 6     ConfigurableEnvironment environment = getOrCreateEnvironment();
 7     //根據用戶配置，配置 environment系統環境
 8     configureEnvironment(environment, applicationArguments.getSourceArgs());
 9     // 啟動相應的監聽器，其中一個重要的監聽器 ConfigFileApplicationListener 就是加載項目配置文件的監聽器。
10     listeners.environmentPrepared(environment);
11     bindToSpringApplication(environment);
12     if (this.webApplicationType == WebApplicationType.NONE) {
13         environment = new EnvironmentConverter(getClassLoader())
14                 .convertToStandardEnvironmentIfNecessary(environment);
15     }
16     ConfigurationPropertySources.attach(environment);
17     return environment;
18 }

 　　看上面的註釋，方法中主要完成的工作，首先是創建並按照相應的應用類型配置相應的環境，然後根據用戶的配置，配置系統環境，然後啟動監聽器，並加載系統配置文件。

4.1、 ConfigurableEnvironment environment = getOrCreateEnvironment(); 

　　看看getOrCreateEnvironment()幹了些什麼。

 1 private ConfigurableEnvironment getOrCreateEnvironment() {
 2     if (this.environment != null) {
 3         return this.environment;
 4     }
 5     //如果應用類型是 SERVLET 則實例化 StandardServletEnvironment
 6     if (this.webApplicationType == WebApplicationType.SERVLET) {
 7         return new StandardServletEnvironment();
 8     }
 9     return new StandardEnvironment();
10 }

 　　通過代碼可以看到根據不同的應用類型初始化不同的系統環境實例。前面咱們已經說過應用類型是怎麼判斷的了，這裏就不在贅述了。

　　從上面的繼承關係可以看出，StandardServletEnvironment是StandardEnvironment的子類。這兩個對象也沒什麼好講的，當是web項目的時候，環境上會多一些關於web環境的配置。

4.2、 configureEnvironment(environment, applicationArguments.getSourceArgs()); 

1 protected void configureEnvironment(ConfigurableEnvironment environment,
2                                     String[] args) {
3     // 將main 函數的args封裝成 SimpleCommandLinePropertySource 加入環境中。
4     configurePropertySources(environment, args);
5     // 激活相應的配置文件
6     configureProfiles(environment, args);
7 }

　　在執行完方法中的兩行代碼后，debug的截圖如下

　　如下圖所示，我在spring的啟動參數中指定了參數：–spring.profiles.active=prod（關於這個參數的用法，點我，其實就是啟動多個實例用的）

　　在configurePropertySources(environment, args);中將args封裝成了SimpleCommandLinePropertySource並加入到了environment中。

　　configureProfiles(environment, args);根據啟動參數激活了相應的配置文件。

　　話不多說，debug一遍就明白了。

4.3、 listeners.environmentPrepared(environment); 

　　進入到方法一路跟下去就到了SimpleApplicationEventMulticaster類的multicastEvent()方法。

　　查看getApplicationListeners(event, type)執行結果，發現一個重要的監聽器ConfigFileApplicationListener。

　　先看看這個類的註釋

 1 /**
 2  * {@link EnvironmentPostProcessor} that configures the context environment by loading
 3  * properties from well known file locations. By default properties will be loaded from
 4  * 'application.properties' and/or 'application.yml' files in the following locations:
 5  * <ul>
 6  * <li>classpath:</li>
 7  * <li>file:./</li>
 8  * <li>classpath:config/</li>
 9  * <li>file:./config/:</li>
10  * </ul>
11  * <p>
12  * Alternative search locations and names can be specified using
13  * {@link #setSearchLocations(String)} and {@link #setSearchNames(String)}.
14  * <p>
15  * Additional files will also be loaded based on active profiles. For example if a 'web'
16  * profile is active 'application-web.properties' and 'application-web.yml' will be
17  * considered.
18  * <p>
19  * The 'spring.config.name' property can be used to specify an alternative name to load
20  * and the 'spring.config.location' property can be used to specify alternative search
21  * locations or specific files.
22  * <p>
23  * 從默認的位置加載配置文件，並將其加入 上下文的 environment變量中
24  */

　　這個監聽器默認的從註釋中<ul>標籤所示的幾個位置加載配置文件，並將其加入 上下文的 environment變量中。當然也可以通過配置指定。

　　debug跳過 listeners.environmentPrepared(environment); 這一行，查看environment屬性，果真如上面所說的，配置文件的配置信息已經添加上來了。

五、第三步：初始化應用上下文

　　在SpringBoot工程中，應用類型分為三種，如下代碼所示。

 1 public enum WebApplicationType {
 2     /**
 3      * 應用程序不是web應用，也不應該用web服務器去啟動
 4      */
 5     NONE,
 6     /**
 7      * 應用程序應作為基於servlet的web應用程序運行，並應啟動嵌入式servlet web（tomcat）服務器。
 8      */
 9     SERVLET,
10     /**
11      * 應用程序應作為 reactive web應用程序運行，並應啟動嵌入式 reactive web服務器。
12      */
13     REACTIVE
14 }

　　對應三種應用類型，SpringBoot項目有三種對應的應用上下文，我們以web工程為例，即其上下文為AnnotationConfigServletWebServerApplicationContext。

 1 public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot."
 2         + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
 3 public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
 4         + "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
 5 public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
 6         + "annotation.AnnotationConfigApplicationContext";
 7         
 8 protected ConfigurableApplicationContext createApplicationContext() {
 9     Class<?> contextClass = this.applicationContextClass;
10     if (contextClass == null) {
11         try {
12             switch (this.webApplicationType) {
13                 case SERVLET:
14                     contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
15                     break;
16                 case REACTIVE:
17                     contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
18                     break;
19                 default:
20                     contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
21             }
22         } catch (ClassNotFoundException ex) {
23             throw new IllegalStateException(
24                     "Unable create a default ApplicationContext, "
25                             + "please specify an ApplicationContextClass",
26                     ex);
27         }
28     }
29     return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
30 }

　　我們先看一下AnnotationConfigServletWebServerApplicationContext的設計。

 　　關於他的繼承體系，我們在前面的博客中<Spring IoC容器與應用上下文的設計與實現>已經詳細介紹了，在此不再贅述。

　　應用上下文可以理解成IoC容器的高級表現形式，應用上下文確實是在IoC容器的基礎上豐富了一些高級功能。

　　應用上下文對IoC容器是持有的關係。他的一個屬性beanFactory就是IoC容器（DefaultListableBeanFactory）。所以他們之間是持有，和擴展的關係。

　　接下來看GenericApplicationContext類

1 public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
2     private final DefaultListableBeanFactory beanFactory;
3     ...
4     public GenericApplicationContext() {
5         this.beanFactory = new DefaultListableBeanFactory();
6     }
7     ...
8 }

 　　beanFactory正是在AnnotationConfigServletWebServerApplicationContext實現的接口GenericApplicationContext中定義的。在上面createApplicationContext()方法中的， BeanUtils.instantiateClass(contextClass) 這個方法中，不但初始化了AnnotationConfigServletWebServerApplicationContext類，也就是我們的上下文context，同樣也觸發了GenericApplicationContext類的構造函數，從而IoC容器也創建了。仔細看他的構造函數，有沒有發現一個很熟悉的類DefaultListableBeanFactory，沒錯，DefaultListableBeanFactory就是IoC容器真實面目了。在後面的refresh()方法分析中，DefaultListableBeanFactory是無處不在的存在感。

　　debug跳過createApplicationContext()方法。

　　如上圖所示，context就是我們熟悉的上下文（也有人稱之為容器，都可以，看個人愛好和理解），beanFactory就是我們所說的IoC容器的真實面孔了。細細感受下上下文和容器的聯繫和區別，對於我們理解源碼有很大的幫助。在系列文章中，我們也是將上下文和容器嚴格區分開來的。

　　原創不易，轉載請註明出處。

　　如有錯誤的地方還請留言指正。

【精選推薦文章】

智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置，台北網頁設計，各種案例分享

廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

導航

• HTTP認證之基本認證——Basic（一）
• HTTP認證之基本認證——Basic（二）
• HTTP認證之摘要認證——Digest（一）
• HTTP認證之摘要認證——Digest（二）

一、概述

Digest認證是為了修復基本認證協議的嚴重缺陷而設計的，秉承“絕不通過明文在網絡發送密碼”的原則，通過“密碼摘要”進行認證，大大提高了安全性。

相對於基本認證，主要有如下改進：

• 絕不通過明文在網絡上發送密碼
• 可以有效防止惡意用戶進行重放攻擊
• 可以有選擇的防止對報文內容的篡改

需要注意的是，摘要認證除了能夠保護密碼之外，並不能保護其他內容，與HTTPS配合使用仍是一個良好的選擇。以下是摘要認證的具體流程圖：

看到上面出現了那麼多之前沒見過的參數，是不是有點慌（或是興奮）？別著急，這裏先給出一個概覽：

• WWW-Authentication：用來定義使用何種方式（Basic、Digest、Bearer等）去進行認證以獲取受保護的資源
• realm：表示Web服務器中受保護文檔的安全域（比如公司財務信息域和公司員工信息域），用來指示需要哪個域的用戶名和密碼
• qop：保護質量，包含auth（默認的）和auth-int（增加了報文完整性檢測）兩種策略，（可以為空，但是）不推薦為空值
• nonce：服務端向客戶端發送質詢時附帶的一個隨機數，這個數會經常發生變化。客戶端計算密碼摘要時將其附加上去，使得多次生成同一用戶的密碼摘要各不相同，用來防止重放攻擊
• nc：nonce計數器，是一個16進制的數值，表示同一nonce下客戶端發送出請求的數量。例如，在響應的第一個請求中，客戶端將發送“nc=00000001”。這個指示值的目的是讓服務器保持這個計數器的一個副本，以便檢測重複的請求
• cnonce：客戶端隨機數，這是一個不透明的字符串值，由客戶端提供，並且客戶端和服務器都會使用，以避免用明文文本。這使得雙方都可以查驗對方的身份，並對消息的完整性提供一些保護
• response：這是由用戶代理軟件計算出的一個字符串，以證明用戶知道口令
• Authorization-Info：用於返回一些與授權會話相關的附加信息
• nextnonce：下一個服務端隨機數，使客戶端可以預先發送正確的摘要
• rspauth：響應摘要，用於客戶端對服務端進行認證
• stale：當密碼摘要使用的隨機數過期時，服務器可以返回一個附帶有新隨機數的401響應，並指定stale=true，表示服務器在告知客戶端用新的隨機數來重試，而不再要求用戶重新輸入用戶名和密碼了

二、剖析

1.當打開需要認證的頁面時，會彈出一個對話框，要求用戶輸入用戶名和密碼

2.使用Fidder監聽請求，可以看到在未進行認證或認證失敗的情況下，服務端會返回401 Unauthorized給客戶端，並附帶Challenge

3.輸入正確的用戶名和密碼后，瀏覽器會生成密碼摘要以及其他信息發送給服務端，服務端認證成功后，返回一些與授權會話相關的附加信息，放在Authorization-Info中。

其中，客戶端選擇的保護質量策略為auth，response就是通過計算得到的密碼摘要，具體計算方式如下（使用默認的MD5加密算法）：

MD5(MD5(A1):<nonce>:<nc>:<cnonce>:<qop>:MD5(A2))

另外，rspauth使得客戶端可以對服務器進行認證，稱為響應摘要。響應摘要的計算與請求摘要類似，但由於響應中沒有方法，而且報文實體數據有所不同，所有隻有報文主題信息A2不同。具體區別如下：

4.當服務端隨機數過期時，再次請求認證，可以看到質詢中增加了stale=true，用戶無需再次輸入用戶名和密碼，瀏覽器會自動使用新的質詢參數進行密碼摘要的計算。

三、注意事項

1.預授權：服務端預先告知客戶端下一個隨機數是多少，使得客戶端可以直接生成正確的Authorization首部，避免了多次“請求/質詢”。常用的有一下三種方式：

• 服務器預先在Authorization-Info成功首部中發送下一個隨機數nextnonce。雖然這種機制加快了事務處理的速度，但是它也破壞了對同一台服務器的多次請求進行管道化的功能，可能會造成很大的損失。
• 服務器允許在一小段時間內使用同一個隨機數。這也就是我們上面剖析中使用的機制，在一定時間內使用同一個隨機數或限制某個隨機數的重用次數，當過期時，聲明stale=true。雖然這確實降低了安全性，但是重用的隨機數的生存周期是可控的，應該在安全和性能之間找到平衡。
• 客戶端和服務器使用同步的、可預測的隨機數生成算法。

2.RFC 2617建議採用這個假想的隨機數公式：

BASE64(timestamp MD5(timestamp “:” ETag “:” private-key))

其中，timestamp是服務器產生隨機數的時間或其他不重複的值，ETag是與所請求實體有關的HTTP ETag首部的值，private-key是只有服務器知道的私鑰。

【精選推薦文章】

自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

裝飾器

什麼是裝飾器

裝飾器顧名思義就是一個有裝飾功能的工具，那麼裝飾器又是用來裝飾什麼的？為什麼要裝飾這個東西？裝飾的目的是什麼呢？本文會一一作答讓小弟一個一個說

開放封閉原則

談及裝飾器就要引申一個概念，那就是開放封閉原則，那麼問題又來了 什麼是開放封閉……好好好，直接說這個，開放封閉本來是兩個對立的概念，也就是說是一對反義詞，那麼為什麼要提出開放封閉原則呢？原因是在日常的開發工作中，一般最初上線的產品的功能是不盡完善的，就是說不夠完美但已經能夠支撐日常使用，其餘的功能可以日後擴展，舉例：N年前的QQ和現在的QQ（PS：雖然現在本人不怎麼用了）。在後期擴展功能時，因為函數已經是寫好的，而且存在大量調用，所以要直接去給函數增添新的功能顯然不現實，所以我們只能新建函數去給原來的函數擴展功能（其實這就是一個裝飾器啦）

那麼開放封閉原則到底是什麼? 答案是對源碼封閉，對新功能開放

• 封閉原則：不要改變源代碼

• 開放原則：能增加一些額外的功能

  如果還有客觀對開放封閉原則似知似解的話，沒關係接着往下看，不影響您食用本文，因為Python裝飾器本身就是對開放封閉原則完美的詮釋

裝飾器初識

不低調的說，裝飾器就是一個函數，名字本來很高大上，但本質就是一個函數，裝飾器函數的功能就是要裝飾一個函數，在不改變被裝飾函數的源代碼及調用方式的前提下，為其增加額外的功能。是不是有點門道了，是不是覺得這玩意也沒啥啦，真是優秀的同學。

代碼show（技術博客不寫代碼干白話說出去丟人）

def warpper(f):  #定義一個函數（裝飾器），傳入的參數是被修飾的函數的函數名
​
 def inner(*args,**kwargs):  #嵌套一個內存函數，這個函數主題才是執行被裝飾函數源碼的關鍵
​
     '''這塊可以加要在被裝飾函數執行之前的操作哈'''
​
     ret = f(*args,**kwargs) #這裏的形參我會在下面說明
​
     '''這裏可以寫被裝飾函數之後的，兄嘚，別客氣，想加啥方法加什麼'''
​
     return ret  #這裏的返回值如果我一會兒不忘的話也會在下面說明
​
 return inner
​
@warpper #這個叫語法糖，嗯……可以吃（可能老外命名的時候就是這麼想的），結構是@加函數名，作用下面會說明
def func():
   print('我就是那個被裝飾的函數')

簡單說明

因為本人比較懶，所以原諒我直接把代碼甩上去了，後面有註釋，看懂了的大佬可以say goodbye啦，想打我的接着聽我白話，那我就把備註再重複一遍，哈哈，你也看到了，裝飾器用到了函數的嵌套（再具體點就是閉包，要問什麼是閉包，百度吧，哈哈），首先外層函數接收到一個函數名，然後返回值是內層函數的函數名；再來內層函數可以接收參數，其中ret = f(*args,**kwargs)有兩個作用，一是執行了傳入的函數，也就是執行了被修飾的函數，二是將返回值賦給了一個變量，此處要說明一下，對被修飾的函數功能的擴展要寫在這裏哦，最後 ret作為內層函數的返回值返回給函數執行者。

語法糖

@warpper這東西和 func = wrapper(func)是一樣的，也就是說最後三行代碼可以這樣寫

#@warpper 
def func():
   print('我就是那個被裝飾的函數')
func = wrapper(func)   #注意奧，這玩意要寫在被裝飾函數的下邊，語法糖才寫上邊

至於為什麼要寫着東西，或者為什麼要用語法糖？請聽下回分解~~~，收起你滴拳頭，是這樣，我剛開始的時候談到了，裝飾器是要在不改變源碼和其調用方式的前提下給其增加新的功能，注意到了么 調用方式 嗯……沒錯就是調用方式，如果我不這樣寫那我是不是要wrapper(func)()這樣去調用啊，是不是有點繞了，但是我把wrapper(func)賦值給了一個和被裝飾函數同名的變量，那我此時要怎麼調用，是不是就是func()，這樣就滿足了開放封閉原則，完美！其實本質就是要把裝飾器“偽裝”成原函數，包括調用方式、參數、返回值，裝就要裝的像一點，對吧。

裝飾帶參數的函數

def wrapper(f):
 def inner(*args,**kwargs):
  f(*args,**kwargs)
 return inner
@wrapper
def func(a,b):
 print(a,b)

函數func中有兩個形參a和b，說一下這兩個參數在裝飾器中的旅程，函數inner的萬能參數接收到a和b打包，然後inner函數充當中間商將打包后的元組給了f，在f中打散又成了變量a和b，在裝飾器時就不會影響傳參了，這就是裝飾帶參數的函數

裝飾有返回值的函數

def wrapper(f):
 def inner():
  ret = f()
  return ret
 return inner
@wrapper
def func():
 return('我不管，我最帥')

哈哈，這段代碼中有我的心聲，你們都懂的，很簡單，裝飾有返回值的參數，在inner函數中將f()賦值給ret，這樣ret就接收到了返回值，再將ret返回給inner()，以此來達到“模擬”被裝飾函數的返回值，也可以說是通過這種方法來拿到被裝飾函數的返回值。

裝飾器帶參數

先舉個例子，當我們需要寫一個簡單的登陸認證功能的時候，我們的目的是要用裝飾器給調用的函數增加一個認證是否登陸過此網站的功能，也就是要驗證用戶名和密碼，但比如不同公司的網站數據庫肯定並非同一個，這個時候就需要帶參數的裝飾器啦，它可以實現我們要用一個裝飾器裝飾多個類似函數的目的

def wrapper_out(n):
    def wrapper(f):
        def inner(*args,**kwargs):
            with open(n,encoding='utf-8') as f1:
            '''此部分省略認證的詳細功能'''
            f(*args,**kwargs)
        return inner
    return wrapper
​
@wrapper_out('webpage1')
def wangzhi1():
    print('歡迎訪問網址1')
    
@wrapper_out('webpage2')
def wangzhi1():
    print('歡迎訪問網址2')

如果使用標準的裝飾器函數的話只能裝飾其中的一個函數，當裝飾另一個函數時會因為訪問不到正確的數據庫而報錯。

@wrapper_out('webpage1')這段代碼先執行wrapper_out('webpage1')這個函數先把參數webpage傳給n，並且返回一個wrapper，此時@和wrapper結合在一塊有沒有很眼熟，沒錯，這就是我們所熟悉的標準的裝飾器了，餘下的流程就和標準的裝飾器完全相同了。

多個裝飾器裝飾一個函數

這是一種特殊的情況，下面重點分析這種情況的結果是如何產生的，會有點繞。

def wrapper1(func1):
     def inner1():
         print('wrapper1 ,before func')
         func1()
         print('wrapper1 ,after func')
     return inner1
​
def wrapper2(func2): # func2 == inner1
     def inner2():
         print('wrapper2 ,before func')
         func2() # inner1
         print('wrapper2 ,after func')
     return inner2
​
@wrapper2  
@wrapper1  
def f():
 print('in f') # 3
​
f()  

結果：

wrapper2,before func
wrapper1,before func
in f
wrapper1,after func
wrapper2,after func

怎麼說？是不是和你預期的結果有所不同，下面來按步驟說一下為什麼會產生這樣的結果（我盡量表達清楚哈）

1. 函數定義不調用不執行直接pass
2.   @wrapper2
 @wrapper1  
 def f():
 單獨看下面這兩行，標準裝飾器哈 @wrapper1 等價於 f = wrapper1(f) = inner1（返回值哈）
3. @wrapper2
   @wrapper1   #注意哈 看步驟2 這裏現在是inner1咯、
   @wrapper2 等價於 inner1 = wrapper2(inner1) = inner2(返回值)
4. 此時的 f = inner2 執行f() 就從inner2()開始執行
5. 執行inner2 首先打印'wrapper2 ,before func'
6. 然後執行func2,由步驟3可知當前wrapper2中的參數是inner1 也就是執行inner1 所以打印wrapper1 ,before func
7. 然後執行func1 參考步驟2 可知這裏的func1()執行的是f()也就是真正的原函數，打印in f
8. 順序執行，打印wrapper1 ,after func
9. inner1執行完（其實就是func2執行完）還是順序執行 打印wrapper2 ,after func
10. 結果出來了、哈哈

這部分本人能力也只能寫成這樣了，各位看官看不懂那一定是小弟沒表述清楚，不過沒關係，在下再支一招，看圖

結合結果分析，相信各位老闆也能推導出正確的結果了，嗯、真帥！

好，到此對Python裝飾器應該有那麼一丟丟的認識了哈，我不管，就得有認識。下面的內容和文章關係不大哈

第一篇正經寫的文章，可能文章內容表達不盡如人意的正經哈，但初心是好的，就是分享知識，分享心得嘛，嗯，不管怎麼說，我還是很欣慰的對自己，哈哈，能有人從中有收穫就更perfect嘍

【精選推薦文章】

智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

帶您來看台北網站建置，台北網頁設計，各種案例分享

廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益