引言觀點

1. 編程語言日新月異，但是從沒有人否定sql 在現代編程中的巨大作用和 持續的可利用性。SQL以對人類友好的閱讀體驗提供數據查詢能力（ 相比其他編程語言 ）， 同時在各種數據庫平台中，基礎SQL元素是相同或大同小異的，

從我們最早接觸的SQL，Mysql到公司大數據impala 支持SQL， Es也提供類似SQL的查詢， 阿里提出SQLFlow AI框架， SQL的生命力極其頑強。

2. 在我近6年的開發生涯中，確實覺得SQL語言沒有得到開發者足夠的重視，尤其是流行的ORM概念使得了編寫SQL機會越來越少，使用ORM映射框架是需要一些代碼的， 另外ORM只能用於基礎的關係型二維查詢，對於複雜的查詢無能為力，部分工作可通過巧妙的SQL查詢，存儲過程，觸發器來完成。

3. SQL編程有許多獨特之處： 面向集合的思維方式、 查詢元素的邏輯處理順序、三值邏輯（three value logic），理解不透的話在實際編寫SQL時會產生很多錯誤的寫法、性能低下的代碼。

1987年SQL稱為ISO標準，ANSI宣布該語言發音為“ess kyoo ell”， 但由於歷史原因，很多專業人士還是將SQL發音成sequel，而且從英文習慣上，sequel發音更為流暢。 互聯網如此之大，容得下不同的聲音。

結合《SQL2008 技術內幕 T-SQL查詢》和工作經驗，提煉出Web開發者需要熟練掌握以下SQL查詢。

• SQL邏輯查詢處理

• SQL 面向集合的思維方式

不敢妄自宣稱是高級編程經驗， 只是認為Web開發者應該Cover這些常見SQL用法。  

SQL邏輯查詢處理

　　開發者、數據分析師每天都在寫【SELECT 列a,聚合函數 FROM 表名 WHERE 過濾條件 GROUP BY 列a HAVING 篩選條件】這樣的查詢語句。

　　SQL與其他語言不同的最明顯特徵是代碼的處理順序，大多數編程語言中，代碼是按照編寫順序來處理的，但在SQL中第一個要處理的子句是FROM子句，儘管SELECT語句第一個出現，但基本都在最後處理。

       每一步都會生成一個虛擬表，該虛擬表會作為下一步的輸入， 這些虛擬表對於調用者（客戶端應用程序或者外部查詢）都是不可用的，只有最後一步生成的虛擬表才會返回給調用者，這種形態可對比LINQ理解。

 

①FROM 　　     FROM階段負責標識表或要查詢的表，如果指定了表運算符（JOIN， APPLY，PIVOT，UNPIVOT ），還要進行表運算符的處理。

　　      　　　　　　例如：表聯接運算中涉及的階段是 笛卡爾積、ON篩選器和 添加外部行，FROM階段生成虛擬表VT1.

②WHERE           這個階段根據在WHERE子句中出現的謂詞對VT1中進行篩選，只有讓謂詞計算結果為TRUE的行，才會插入VT2中。

③GROUP BY     按照GROUP BY 子句中指定的列名列表，對VT2中的行進行分組，生成VT3， 最終每個分組只有一個結果行。

④HAVING          根據HAVING子句中出現的謂詞，對VT3中行記錄進行篩選，只有讓謂詞結果為TRUE的行記錄，才會進入VT4， Having 篩選器是唯一可用於分組數據的篩選器。

⑤SELECT 　　 處理SELECT子句中字段（某些字段可能進行一些操作，形成新的字段），形成虛擬表VT5

⑥ORDER BY 　根據ORDER BY子句中指定的列名列表，對VT5 中行進行排序，輸出最後結果。

 

着重理解：

• 第一步的FROM表運算， 一般情況下是TABLE、TempTable,CTE, 還有可能是表運算符（我們常用的是聯接運算符）， 所以不能單純認為FROM後面是一個表結構。

• 表聯接運算符  ON篩選器 與 WHERE有所不同，若採用OUTER JOIN, 應用ON篩選出來的結果不一定是此階段最終結果，因為涉及【添加外部行】， 而WHERE過濾出的結果是此階段的最終結果。 

• GROUP BY x,y 意味着將（x,y）作為一個整體來分組

• 有SELECT 和WHERE的時候，先執行WHERE，再執行SELECT，這樣就很容易理解以下SQL的業務含義：

SELECT page_original_url,server_session_id,access_order-1 as access_order FROM PageViewMeasure WHERE access_order >= 2
--- 查詢過濾出access_order>=2的基礎數據集，然後將（原列值-1）重命名為原列名，重命名的用法業務上也許是為了形成新的SQL聯接

SELECT keyword_id,Coalesce(full_keywords,keywords)  as  not_nullField,profile_id,session_server_time,count (*) over () as Count FROM pageview 
WHERE  profile_id =5254 and keyword_id != '-' and day =20181008  and  not_nullField !='-'   
ORDER BY session_server_time 
--- SQL報錯：Could not resolve column/field reference: 'not_nullfield' 也容易理解了：先執行where， 執行where的時候not_nullField字段還沒有形成

• ROW_NUMBER() OVER(PARTITION BY UserId ORDER BY PageViewServerTime)排名函數中ORDER BY 與SQL語句最後的ORDER BY 同時存在，哪個ORDER BY起最終排序作用？

SELECT page_original_url as name,page_view_server_time, ROW_NUMBER() OVER(PARTITION BY page_original_url ORDER BY page_view_server_time ) as partition_rank ,wd3_page_duration
  FROM pageview WHERE profile_id=5198 AND day between 20190616 and 20190621   
  ORDER  BY wd3_page_duration desc 
  LIMIT 100

　　可以認為 ROW_NUMBER() OVER(PARTITION BY col1 ORDER BY col2) as rank 本質上還是產生一個列值，實際是對應以上的第⑤步，因此SQL最後的ORDER BY起最終排序作用，例證如下：

           某些轉載文章寫有： 以上over函數里的分組及排序的執行晚於“where，group by，order by”的執行 ，這樣的結論是錯誤的

• 若存在LIMIT子句，則LIMIT子句必須在ORDER BY 語法之後

 

　　　　　　上圖來自《SQL技術內幕T-SQL查詢》邏輯查詢處理一章

 

 這裏拋出一個困惑點：

　　在FROM子句中，若存在JOIN表運算符， 可能會按照 【計算笛卡爾積】 【應用ON篩選】【添加外部行】的順序來完成 JOIN的過程， 但是試想一下： 如果兩個表都為大表，先計算笛卡爾積，再篩選 豈不很費內存，

　　我也搜索了很多資料，某些資料認為先進行【ON篩選】再進行【JOIN】運算：

https://www.cnblogs.com/liuzhendong/archive/2011/10/27/2226805.html

https://docs.microsoft.com/en-us/previous-versions/sql/sql-server-2008/ms189499(v=sql.100)

我更願意相信《SQL技術內幕T-SQL查詢》書中所言:

本章描述的某些邏輯處理步驟可能看起來非常低效，但要記住， 在實踐中，
查詢的實際物理處理可能與邏輯處理有很大不同。

在SQL Server 中負責生成實際工作計劃的組件是查詢優化器，以何種順序訪問表、使用什麼訪問方法和索引，應用哪種聯接算法等都是查詢優化器來決定的，優化器會生成多個有效執行計劃並選擇一個開銷最低的計劃。

邏輯查詢處理中各個階段都有其特定的順序，而優化器缺經常可以在它生成的物理執行計劃中走捷徑。

 我們思考一個簡單的SQL：

SELECT * FROM pageview LEFT JOIN  share  ON  pageview.share_pv_id = share.page_view_id
 WHERE pageview.profile_id =5313 AND pageview.day  between 20190615 and 20190624

若實際物理查詢按照上面描述的 邏輯查詢處理， 先進行 FROM 子句中的 LEFT JOIN 計算，再進行 WHERE過濾， 根本無法查出（在FROM子句可能內存就爆滿了）

　　現在我們能夠查詢出來，能夠印證 實際物理查詢確實與邏輯查詢處理有很大不同。 

PS: 以上是個人從現象上推斷書中理論，對於實際物理查詢處理並沒有理論支持，若網友們有相關資料，可留言給我。

 

作者： JulianHuang

感謝您的認真閱讀，如有問題請大膽斧正；覺得有用，請下方或加關注。

本文歡迎轉載，但請保留此段聲明，且在文章頁面明顯位置註明本文的作者及原文鏈接。

【精選推薦文章】

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

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

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

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

作者：追夢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網頁設計已成為網頁設計推薦首選

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

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

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

前言

       轉載請聲明，轉自【https://www.cnblogs.com/andy-songwei/p/11072989.html】，謝謝！

       前面兩篇文章，花了很大篇幅講解了Android的事件分發機制的原理性知識。然而，“紙上得來終覺淺，絕知此事要躬行”，前面講的那些原理，也都是為解決實際問題而服務的。本文將結合實際工作中經常遇到的滑動衝突案例，總結滑動衝突的場景以及解決方案。本文的主要內容如下：

 

一、滑動衝突簡介

       滑動組合在平時的UI開發中非常常見，比如下圖中某App界面（圖片來源：https://www.jb51.net/article/90032.htm），該頁面上半部分显示商品列表，而下半部分显示頁面導航。當滑動上面的列表時，列表部分滑動；當列表滑動到底或者滑動下半部分時，整個頁面一起滑動。

       但是在平時的開發中，可能會經常遇到這樣的場景，滑動列表部分時，整個頁面一起滑動，而不是只滑動列表內容。或者一會兒是列表滑動，一會兒是整個頁面滑動，而不是按照預期的要求來滑動。這就是我們常說的滑動衝突問題。滑動衝突的問題，經常讓開發者們頭痛不已。因為經常很多滑動相關的控件，如ScrollView、ListView等，在單獨使用的時候酷炫不已，但將他們組合在一起使用，就失靈了。比如上圖中，手指在屏幕上上下滑動，列表和整個頁面都有滑動功能，此時如果處理不當，就會導致系統也不知道要讓誰來消費這個滑動事件，這就是滑動衝突產生的原因。

 

二、滑動衝突的三種場景

       儘管實際工作中滑動衝突的場景看似各種各樣，但最終可以歸納為三種，如下圖所示：1）圖一：外部滑動和內部滑動方向不一致；2）圖二：外部滑動和內部滑動方向不一致；3）圖三：多層滑動疊加。

 

  1、外部滑動和內部滑動方向不一致

       圖一中只示意了外部為左右滑動，內部為上下滑動的場景。顯然，內外滑動不一致，還包括外部為上下滑動，內部為左右滑動的場景。對於這種場景，平時工作中最常見的使用大概是外層為PageView，內層為一個Fragment+ListView/RecyclerView了。慶幸的是，控件PageView和RecyclerView對事件衝突做了處理的，所以平時使用這兩個控件的時候不會感受到滑動衝突的存在。如果是ScrollView+GridView等這類組合，就需要解決衝突了。

  2、外部滑動和內部滑動方向一致

       同樣，這種場景除了圖二中的內外都是上下滑動的情況外，還包括內外到時左右滑動的場景了。ScollView(垂直滾動)+ListView的組合就是比較常見的場景。第一節中的動態圖就是一個外部滑動和內部滑動方向一致的例子。

  3、多層滑動嵌套

       這種場景一般就是前面兩種場景的嵌套。“騰訊新聞”客戶端就是典型的多層滑動嵌套的使用案例，如下圖中，圖一的左邊是主頁向右滑動時才出現的滑動側邊欄，圖二是主頁界面，頂部導航欄在主頁左右滑動時可以切換，整個“要聞”界面可以上下滑動，“熱點精選”是一個可以左右滑動的橫向列表，下方還有豎直方向的列表……可見這其中嵌套層數不少。

           

 

三、滑動衝突三種場景的處理思路

       儘管滑動衝突看起來比較複雜，但是上述將它們分為三類場景后，就可以根據這三類場景來分別找出對應的分析思路。

  1、內外滑動方向不一致時處理思路

       這一類場景其實比較容易分析，因為外層和內層滑動的方向不一致，所以根據手勢的動向來確定把事件給誰。我們前面兩篇文章中分析過，默認情況下，當點擊內層控件時，事件會先一層層從外層傳到內層，由內層來處理。這裏以外層為左右滑動，內層為上下滑動為例。當判定手勢的滑動為左右時，需要外層來消費事件，所以外層將事件攔截，即在外層的onInterceptTouchEvent中檢測為ACTION_MOVE時返回true；而如果判定手勢的滑動為上下時，需要內層來消費事件，外層不需要攔截，事件會傳遞到內層來處理（具體的代碼實現，在後面會詳細列出）。這樣就通過判斷滑動的方向來決定事件的處理對象，從而解決滑動衝突的問題。

       那麼，如何來判定手勢的滑動方向呢？最常用的辦法就是比較水平和豎直方向上的位移值來判斷。 MotionEvent事件包含了事件的坐標，只要記錄一次移動事件的起點和終點坐標，如下圖所示，通過比較在水平方向的位移|dx|和|dy|的大小，來決定滑動的方向：|dy|>|dx|，本次移動的方向認為是豎直方向；反之，則認為是水平方向。當然，還可以通過夾角α的大小、斜率、速率等方式來作為判斷條件。

  2、內外滑動方向一致時處理思路

       這種場景要比上面一種複雜一些，因為滑動方向一致，所以無法通過上述的方式來判斷將事件交給誰處理。在這種情況下，往往需要根據業務的需要來判定誰來處理事件。比如豎直方向的ScrollView嵌套ListView的場景下，手指在ListView上上下滑動時：當ListView滑動到頂部且手勢向下時，顯然ListView不能再向下滑動了，這種情況下事件需要被外層控件攔截，由ScrollView來消費；當ListView滑動到底部且手勢向上時，顯然ListView也不能再向上滑動了，這種情況下事件也需要被外層控件攔截，由ScrollView來消費；其它情況下，ScrollView就不能再攔截了，滑動事件就需要由ListView來消費了，即此時上下滑動時，滑動的是ListView，而不是ScrollView。後面會以這為案例進行編碼實現。

  3、多層滑動嵌套時處理思路

       場景3看起來比較複雜，但前面也說過了，也是由前面兩種場景嵌套形成的。所以在處理場景的處理方式，就是將其拆分為簡單的場景，然後按照前面的場景分析方式來處理。

 

四、滑動衝突的兩種解決套路

       前面我們將滑動衝突分為了3種場景，並根據每一種場景提供了解決衝突的思路。但是這些思路解決的是判斷條件問題，即什麼情況下事件交給誰的問題。這一節將拋開前面的場景分類，介紹對所有場景適用的兩種通用解決方法，可以通俗地理解為處理滑動衝突的“套路”。這兩種解決滑動衝突的方式為：外部攔截法和內部攔截法。

  1、外部攔截法

       顧名思義，就是在外部滑動控件中處理攔截邏輯。這需要外部控件重寫父類的onInterceptTouchEvent方法，在其中判斷什麼時候需要攔截事件由自身處理，什麼時候需要放行將事件傳給內層控件處理，內部控件不需要做任何處理。這個“套路”的偽代碼錶示所示：

 1 @Override
 2 public boolean onInterceptTouchEvent(MotionEvent ev) {
 3     boolean intercepted = false;
 4     switch (ev.getAction()){
 5         case MotionEvent.ACTION_DOWN:
 6             intercepted = false;
 7             break;
 8         case MotionEvent.ACTION_MOVE:
 9             if(父容器需要自己處理改事件){
10                 intercepted = true;
11             }else {
12                 intercepted = false;
13             }
14             break;
15         case MotionEvent.ACTION_UP:
16             intercepted = false;
17             break;
18             default:
19             break;
20     }
21     return intercepted;
22 }

前面對滑動處理的場景分類，並對不同場景給了分析思路，它們的作用就是在這裏的第9行來做判斷條件的。所以，不論什麼場景，都可以在這個套路的基礎上，修改判斷是否攔截事件的條件語句即可。另外，需要說明一下的是，第6行和第16行，這裏都賦值為false，因為ACTION_DOWN如果被攔截了，該動作序列的其它事件就都無法傳遞到子View中了，ListView也就永遠不能滑動了；而ACTION_UP如果被攔截，那子View就無法被點擊了，這兩點我們前面的文章都講過，這裏再強調一下。

 

  2、內部攔截法

       顧名思義，就是將事件是否需要攔截的邏輯，放到內層控件中來處理。這種方式需要結合requestDisllowInterceptTouchEvent(boolean)，在內層控件的重寫方法dispatchTouchEvent中，根據邏輯來決定外層控件何時需要攔截事件，何時需要放行。偽代碼如下：

 1 @Override
 2 public boolean dispatchTouchEvent(MotionEvent ev) {
 3     switch (ev.getAction()){
 4         case MotionEvent.ACTION_DOWN:
 5             getParent().requestDisallowInterceptTouchEvent(true);
 6             break;
 7         case MotionEvent.ACTION_MOVE:
 8             if (父容器需要處理改事件) {
 9                 //允許外層控件攔截事件
10                 getParent().requestDisallowInterceptTouchEvent(false);
11             } else {
12                 //需要內部控件處理該事件，不允許上層viewGroup攔截
13                 getParent().requestDisallowInterceptTouchEvent(true);
14             }
15             break;
16         case MotionEvent.ACTION_UP:
17             break;
18         default:
19             break;
20     }
21     return super.dispatchTouchEvent(ev);
22 }

除此之外，還需要外層控件在onInterceptTouchEvent中做一點處理：

1 @Override
2 public boolean onInterceptTouchEvent(MotionEvent ev) {
3     if (ev.getAction() == MotionEvent.ACTION_DOWN) {
4         return false;
5     } else {
6         return true;
7     }
8 }

ACTION_DOWN事件仍然不能攔截，上一篇文章分析源碼的時候講過，ACTION_DOWN時會初始化一些狀態和標誌位等變量，requestDisllowInterceptTouchEvent(boolean)作用會失效。這裏再順便強調一下，不明白的可以去上一篇文章中閱讀這部分內容。 

       這種方式比“外部攔截法”稍微複雜一些，所以一般推薦使用前者。同前者一樣，這也是一個套路用法，無論是之前提到的何種場景，只要根據實際判斷條件修改上述if語句即可。對於requestDisllowInterceptTouchEvent(boolean)的相關信息，在前面的文章中介紹過，這裏不再贅述了。

 

 五、代碼示例

       前面通過文字描述和偽代碼，對滑動衝突進行了介紹，並提供了一些對應的解決方案。本節將通過一個具體的實例，分別使用上述的套路來解決一個滑動衝突，從而具體演示前面“套路”的使用。

  1、未解決衝突前的示例情況

       本示例外層為一個ScrollView，內層為TextView+ListView+TextView，這兩個TextView分別為“Tittle”和”Bottom”，显示在ListView的頂部和底部，添加它們是為了方便觀察ScrollView的滑動效果。最終的布局效果如下所示：

在手機上的显示效果為：

     

在沒有解決衝突前，如果滑動中間的ListView部分，會出現ListView中的列表內容不會滑動，而是整個ScrollView滑動的現象，或者一會兒ListView滑動，一會兒ScrollView滑動。顯然，這不是我們希望看到的結果。我們希望的是，如果ListView滑到頂部時，而且手勢繼續下滑時，整個頁面下滑，即ScrollView滑動；如果ListView滑到底部了，而且手勢繼續上滑時，希望整個頁面上滑，即也是ScrollView向上滑動。

 

  2、用外部攔截法解決滑動衝突的示例

       前面說過了，這種方式需要外層的控件在重寫的onInterceptTouchEvent時進行攔截判斷，所以需要自定義一個ScrollView控件。

 1 public class CustomScrollView extends ScrollView {
 2 
 3     ListView listView;
 4     private float mLastY;
 5     public CustomScrollView(Context context, AttributeSet attrs) {
 6         super(context, attrs);
 7     }
 8 
 9     @Override
10     public boolean onInterceptTouchEvent(MotionEvent ev) {
11         super.onInterceptTouchEvent(ev);
12         boolean intercept = false;
13         switch (ev.getAction()){
14             case MotionEvent.ACTION_DOWN:
15                 intercept = false;
16                 break;
17             case MotionEvent.ACTION_MOVE:
18                 listView = (ListView) ((ViewGroup)getChildAt(0)).getChildAt(1);
19                    //ListView滑動到頂部，且繼續下滑，讓scrollView攔截事件
20                 if (listView.getFirstVisiblePosition() == 0 && (ev.getY() - mLastY) > 0) {
21                     //scrollView攔截事件
22                     intercept = true;
23                 }
24                 //listView滑動到底部，如果繼續上滑，就讓scrollView攔截事件
25                 else if (listView.getLastVisiblePosition() ==listView.getCount() - 1 && (ev.getY() - mLastY) < 0) {
26                     //scrollView攔截事件
27                     intercept = true;
28                 } else {
29                     //不允許scrollView攔截事件
30                     intercept = false;
31                 }
32                 break;
33             case MotionEvent.ACTION_UP:
34                 intercept = false;
35                 break;
36             default:
37                 break;
38         }
39         mLastY = ev.getY();
40         return intercept;
41     }
42 }

       相比於前面的偽代碼，這裏需要注意一點的是多了第12行。因為本控件是繼承自ScrollView，而ScrollView中的onInterceptTouchEvent做了很多的工作，這裏需要使用ScrollView中的處理邏輯，才需要加上這一句。如果是完全自繪的控件，即直接繼承自ViewGroup，那就無需這一句了，因為控件需要自己完成自己的特色功能。第18行是獲取子控件ListView的實例，這個是參照後面的布局文件activity_event_examples來定位的，也可以通過其它的方式來獲取實例。另外就是ListView的實例可以通過其它方式一次性賦值，而不用這裏每次ACTION_MOVE都獲取一次實例，從性能上考慮會更好，這裏為了便於演示，先忽略這一點。其它要點在註釋中也說得比較明確了，這裏不贅述。

       使用CustomScrollView控件，界面的布局如下：

 1 //==============activity_event_examples=============
 2 <?xml version="1.0" encoding="utf-8"?>
 3 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 4     android:layout_width="match_parent"
 5     android:layout_height="match_parent"
 6     android:orientation="vertical">
 7 
 8     <com.example.demos.customviewdemo.CustomScrollView
 9         android:id="@+id/demo_scrollview"
10         android:layout_width="match_parent"
11         android:layout_height="match_parent">
12 
13         <LinearLayout
14             android:layout_width="match_parent"
15             android:layout_height="match_parent"
16             android:orientation="vertical">
17 
18             <TextView
19                 android:id="@+id/tv_title"
20                 android:layout_width="match_parent"
21                 android:layout_height="100dp"
22                 android:background="@android:color/darker_gray"
23                 android:gravity="center"
24                 android:text="Title"
25                 android:textSize="50dp" />
26 
27             <ListView
28                 android:id="@+id/demo_lv"
29                 android:layout_width="match_parent"
30                 android:layout_height="600dp" />
31 
32             <TextView
33                 android:layout_width="match_parent"
34                 android:layout_height="100dp"
35                 android:background="@android:color/darker_gray"
36                 android:gravity="center"
37                 android:text="Bottom"
38                 android:textSize="50dp" />
39         </LinearLayout>
40     </com.example.demos.customviewdemo.CustomScrollView>
41 </LinearLayout>

這裏需要注意的是，在ScrollView中嵌套ListView時，ListView的高度需要特別處理，如果設置為match_parent或者wrap_content，都會一次只能看到一條item，所以上面給了固定的高度600dp來演示效果。平時工作中，往往還需要對ListView的高度做一些特殊的處理，這不是本文的重點，這裏不細講，讀者可以自行去研究。

       最後就是給ListView填充足夠的數據：

 1 public class EventExmaplesActivity extends AppCompatActivity {
 2 
 3     private String[] data = {"Apple", "Banana", "Orange", "Watermelon",
 4             "Pear", "Grape", "Pineapple", "Strawberry", "Cherry", "Mango",
 5             "Apple", "Banana", "Orange", "Watermelon",
 6             "Pear", "Grape", "Pineapple", "Strawberry", "Cherry", "Mango"};
 7 
 8     @Override
 9     protected void onCreate(Bundle savedInstanceState) {
10         super.onCreate(savedInstanceState);
11         setContentView(R.layout.activity_event_exmaples);
12         showList();
13     }
14 
15     private void showList() {
16         ArrayAdapter<String> adapter = new ArrayAdapter<String>(
17                 EventExmaplesActivity.this, android.R.layout.simple_list_item_1, data);
18         ListView listView = findViewById(R.id.demo_lv);
19         listView.setAdapter(adapter);
20     }
21 }

 

  3、用內部攔截法解決滑動衝突的示例

       同樣，前面的偽代碼中也講過，這裏需要在內層控件中重寫的dispatchTouchEvent方法處判斷外層控件的攔截邏輯，所以首先需要自定義ListView。

 1 public class CustomListView extends ListView {
 2 
 3     public CustomListView(Context context, AttributeSet attrs) {
 4         super(context, attrs);
 5     }
 6 
 7     //為listview/Y，設置初始值,默認為0.0(ListView條目一位置)
 8     private float mLastY;
 9 
10     @Override
11     public boolean dispatchTouchEvent(MotionEvent ev) {
12         int action = ev.getAction();
13         switch (action) {
14             case MotionEvent.ACTION_DOWN:
15                 //不允許上層的ScrollView攔截事件.
16                 getParent().requestDisallowInterceptTouchEvent(true);
17                 break;
18             case MotionEvent.ACTION_MOVE:
19                 //滿足listView滑動到頂部，如果繼續下滑，那就允許scrollView攔截事件
20                 if (getFirstVisiblePosition() == 0 && (ev.getY() - mLastY) > 0) {
21                     //允許ScrollView攔截事件
22                     getParent().requestDisallowInterceptTouchEvent(false);
23                 }
24                 //滿足listView滑動到底部，如果繼續上滑，允許scrollView攔截事件
25                 else if (getLastVisiblePosition() == getCount() - 1 && (ev.getY() - mLastY) < 0) {
26                     //允許ScrollView攔截事件
27                     getParent().requestDisallowInterceptTouchEvent(false);
28                 } else {
29                     //其它情形時不允ScrollView攔截事件
30                     getParent().requestDisallowInterceptTouchEvent(true);
31                 }
32                 break;
33             case MotionEvent.ACTION_UP:
34                 break;
35         }
36 
37         mLastY = ev.getY();
38         return super.dispatchTouchEvent(ev);
39     }
40 }

可能有讀者會有些疑惑，從布局結構上看，listView和ScrollView之間還隔了一層LinearLayout，getParent().requestDisallowInterceptTouchEvent(boolean)方法會奏效嗎？實際上這個方法是針對所有的父布局的，而不是只針對直接父布局，這一點需要注意。

       參照偽代碼的套路，這裏還需要對外層的ScrollView做一些邏輯處理：

 1 public class CustomScrollView extends ScrollView {
 2     public CustomScrollView(Context context, AttributeSet attrs) {
 3         super(context, attrs);
 4     }
 5 
 6     @Override
 7     public boolean onInterceptTouchEvent(MotionEvent ev) {
 8         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 9             return false;
10         } else {
11             return true;
12         }
13     }
14 }

       在布局文件中使用CustomListView，將前面activity_event_examples.xml布局文件中的第27行的ListView替換為com.example.demos.customviewdemo.CustomListView即可。其它的和前面外部攔截法示例一樣，這裏不贅述。

 

結語

       關於滑動衝突的內容就講完了。實際工作中的場景可能比這裏demo中要複雜一些，筆者為了突出重點，所舉的例子選得比較簡單，但原理都一樣的，所以希望讀者能夠好好理解，重要的地方，甚至需要記下來。同樣，Android事件分發機制系列的知識點，要講的也講完了，三篇文章側重於三個方面：1）第一篇重點總結了Touch相關的三個重要方法對事件的處理邏輯；2）第二篇重點分析源碼，從源碼的角度來分析第一篇文章中的邏輯；3）第三篇重點在實踐，側重解決實際工作中經常遇到的事件衝突問題——滑動衝突。當然，事件分發相關的問題遠不是這3篇文章能說清楚的，文中若有描述錯誤或者不妥的地方，歡迎讀者來拍磚！！！

 

參考資料

       任玉剛《Android開發藝術探索》

【精選推薦文章】

如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

想要讓你的商品在網路上成為最夯、最多人討論的話題?

網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師"嚨底家"!!

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網頁設計已成為網頁設計推薦首選

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

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

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

十多年來，NAS中已經存在的目錄和文件達到10億之多，在設計和開發備份系統的過程中碰到了很多挑戰，本文將分享大量文件名記錄的樹形結構存儲實踐。

一、引言

既然是定期備份，肯定會有1次以上的備份。對於一個特定目錄，每次備份時都要與上次備份時進行比較，以期找出哪些文件被刪除了，又新增了哪些文件，這就需要每次備份時把該目錄下的所有文件名進行保存。我們首先想到的是把所有文件名用特定字符進行拼接后保存。由於我們使用了MySQL保存這些信息，當目錄下文件很多時，這種拼接的方式很可能超出MySQL的Blob長度限制。根據經驗，當一個目錄有大量文件時，這些文件的名稱往往是程序生成的，有一定規律的，而且開頭一般是重複的，於是我們想到了使用一種樹形結構來進行存儲。

例如，一個有abc、abc1、ad、cde 4個文件的目錄對應的樹如圖1所示。

圖1 樹形結構示例

圖1中，R表示根節點，青色節點我們稱為結束節點，從R到每個結束節點的路徑都表示一個文件名。可以在樹中查找是否含有某個文件名、遍歷樹中所有的文件名、對樹序列化進行保存、由序列化結果反序列化重新生成樹。

二、涉及的數據結構

注意：我們使用java編寫，文中涉及語言特性相關的知識點都是指java。

2.1 Node的結構

包括根節點在內的每個節點都使用Node類來表示。代碼如下：

 class Node {
        private char value;
        private Node[]children = new Node[0];
        private byte end = 0;
    }

 

字段說明：

• value：該節點表示的字符，當Node表示根節點時，value無值。
• children：該節點的所有子節點，初始化為長度為0的數組。
• end：標記節點是否是結束節點。0不是；1是。恭弘=恭弘=恭弘=叶 恭弘 恭弘 恭弘子節點肯定是結束節點。默認非結束節點。

2.2 Node的操作

   public Node(char v);
    public Node findChild(char v);
    public Node addChild(char v);

 

操作說明：

• Node：構造方法。將參數v賦值給this.value。
• findChild：查找children中是否含有value為v的子節點。有則返回子節點，沒有則返回null。
• addChild：首先查找children中是否已經含有value為v的子節點，如果有則直接將查到的子節點返回；否則創建value為v的節點，將children的長度延長1，將新創建的節點作為children的最後一個元素，並返回新創建的節點。

2.3 Tree的結構

  class Tree {
        public Node root = new Node();
    }

 

字段說明：Tree只含有root Node。如前所述，root的value無值，end為0。初始時的children長度為0。

2.4 Tree的操作

  public void addName(String name) ;
    public boolean contain(String name);
    public Found next(Found found);
    public void writeTo(OutputStream out);
    public static Tree readFrom(InputStream in);

 

操作說明：

• addName：向樹中增加一個新的文件名，即參數name。以root為起點，name中的每個字符作參數調用addChild，返回值又作為新的起點，直到name中的全部字符添加完畢，對最後一次調用addChild的返回值標記為結束節點。
• contain：查詢樹中是否含有一個文件名。
• next：對樹中包含的所有文件名進行遍歷，為了使遍歷能夠順利進行，我們引入了新的類Found，細節會在後文詳述。
• writeTo：將樹寫入一個輸出流以進行持久化。
• readFrom：此方法是靜態方法。從一個輸入流來重新構建樹。

三、樹的構建

在新建的Tree上調用addName方法，將所有文件名添加到樹中，樹構建完成。仍然以含有abc、abc1、ad、cde 四個文件的目錄為例，對樹的構建進行圖示。

圖2 樹的構建過程

圖2中，橙色節點表示需要在該節點上調用addChild方法增加子節點，同時addChild的返回值作為新的橙色節點。直到沒有子節點需要增加時，把最後的橙色節點標記為結束節點。

四、樹的查詢

查找樹中是否含有一個某個文件名，對應Tree的contain方法。在圖2中的結果上分別查找ef、ab和abc三個文件來演示查找的過程。如圖3所示。

圖3 樹的查詢示意圖

圖3中，橙色節點表示需要在該節點上調用findChild方法查找子節點。

五、樹的遍歷

此處的遍歷不同於一般樹的遍歷。一般遍歷是遍歷樹中的節點，而此處的遍歷是遍歷根節點到所有結束節點的路徑。

我們採用從左到右、由淺及深的順序進行遍歷。我們引入了Found類，並作為next方法的參數進行遍歷。

5.1 Found的結構

 class Found {    
        private String name;
        private int[] idx ;
    }

 

為了更加容易的說明問題，在圖1基礎上進行了小小的改造，每個節點的右下角增加了下標，如圖4。

圖4 帶下標的Tree

對於abc這個文件名，Found中的name值為“abc”，idx為{0，0，0}。

對於abc1這個文件名，Found中的name值為“abc1”，idx為{0，0，0，0}。

對於ad這個文件名，Found中的name值為“ad”，idx為{0，1}。

對於cde這個文件名，Found中的name值為“cde”，idx為{1，0，0}。

5.2 如何遍歷

對於圖4而言，第一次調用next方法應傳入null，則返回第一個結果，即abc代表的Found；繼續以這個Found作為參數進行第二次next的調用，則返回第二個結果，即abc1代表的Found；再繼續以這個Found作為參數進行第三次next的調用，則返回第三個結果，即ad所代表的Found；再繼續以這個Found作為參數進行第四次next的調用，則返回第四個結果，即cde所代表的Found；再繼續以這個Found作為參數進行第五次調用，則返回null，遍歷結束。

六、序列化與反序列化

6.1 序列化

首先應該明確每個節點序列化后應該包含3個信息：節點的value、節點的children數量和節點是否為結束節點。

6.1.1 節點的value

雖然之前所舉的例子中節點的value都是英文字符，但實際上文件名中可能含有漢字或者其他語言的字符。為了方便處理，我們沒有使用變長編碼。而是直接使用unicode碼。字節序採用大端編碼。

6.1.2 節點的children數量

由於節點的value使用了unicode碼，所以children的數量不會多於unicode能表示的字符的數量，即65536。children數量使用2個字節。字節序同樣採用大端編碼。

6.1.3 節點的end

0或1可以使用1位（1bit）來表示，但java中最小單位是字節。如果採用1個字節來表示end，有些浪費空間，其實任何一個節點children數量達到65536/2的可能性都是極小的，因此我們考慮借用children數量的最高位來表示end。

綜上所述，一個節點序列化后佔用4個字節，以圖4中的根節點、value為b的節點和value為e的節點為例：

表1 Node序列化示例

	value的unicode	children數量	end	children數量/(end<<15)	最終結果
根節點	0x0000	2	0	0x0002	0x00020000
b節點	0x0062	1	0	0x0001	0x00010062
e節點	0x0065	0	1	0x8000	0x80000065

6.1.4 樹的序列化過程

對樹進行廣度遍歷，在遍歷過程中需要藉助隊列，以圖4的序列化為例進行說明： 

圖5 對圖4的序列化過程

6.2 反序列化

反序列化是序列化的逆過程，由於篇幅原因不再進行闡述。值得一提的是，反序列化過程同樣需要隊列的協助。

七、討論

7.1 關於節省空間

為方便討論，假設目錄下的文件名是10個阿拉伯数字的全排列，當位數為1時，目錄下含有10個文件，即0、1、2……8、9，當位數為2時，目錄下含有100個文件，即00、01、02……97、98、99，以此類推。

比較2種方法，一種使用“/”分隔，另一種是本文介紹的方法。

表2 2種方法的存儲空間比較（單位：字節）

位數 方法	1	2	3	4	5	6
“/”分隔	19	299	3999	49999	599999	6999999
Tree	44	444	4444	44444	444444	4444444

由表2可見，當位數為4時，使用Tree的方式開始節省空間，位數越多節省的比例越高，這正是我們所需要的。

表中，使用“/”分隔時，字節數佔用是按照utf8編碼計算的。如果直接使用unicode進行存儲，佔用空間會加倍，那麼會在位數為2時就開始節省空間。同樣使用“/”分隔，看起來utf8比使用unicode會更省空間，但實際上，文件名中有時候會含有漢字，漢字的utf8編碼佔用3個字節。

7.2 關於時間

在樹的構建、序列化反序列化過程中，引入了額外的運算，根據我們的實踐，user CPU並沒有明顯變化。

7.3 關於理想化假設

最初我們就是使用了“/”分隔的方法對文件名進行存儲，並且數據庫的相應字段類型是Blob（Blob的最大值是65K）。在測試階段就發現，超出65K是一件很平常的事情。在不可能預先統計最大目錄里所有文件名拼接后的大小的情況下，我們採取了2種手段，一是使用LongBlob類型，另一種就是盡量減小拼接結果的大小，即本文介紹的方法。

即使使用樹形結構來存儲文件名，也不能夠保證最終結果不超出4G(LongBlob類型的最大值)，至少在我們實踐的過程並未出現問題，如果真出現這種情況，只能做特殊處理了。

7.4 關於其他壓縮方法

把文件名使用“/”拼接后，使用gzip等壓縮算法對拼接結果進行壓縮后再存儲，在節省存儲空間方面會取得更好的效果。但是在壓縮之前，拼接結果存在於內存，這樣對JVM的堆內存有比較高的要求；另外，使用“/”拼接時，查找會比較麻煩。

作者：牛寧昌

來源：宜信技術學院

【精選推薦文章】

如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

想要讓你的商品在網路上成為最夯、最多人討論的話題?

網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師"嚨底家"!!

     最近做項目，使用的是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。

五、操作對比

圖表類型	1天數據	7天數據	14天數據
Echarts	卡頓	無法操作	瀏覽器崩潰
HighCharts	流暢	流暢	流暢

 

雲端操作系統：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網頁設計已成為網頁設計推薦首選

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

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

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

一、項目初始化

　　創建webpack模板項目如下所示：

MacBook-Pro:PycharmProjects hqs$ vue init webpack luffy_project

? Project name luffy_project
? Project description A Vue.js project
? Author hqs
? Vue build standalone
? Install vue-router? Yes
? Use ESLint to lint your code? No
? Set up unit tests No
? Setup e2e tests with Nightwatch? No
? Should we run `npm install` for you after the project has been created? (recommended) npm

   vue-cli · Generated "luffy_project".

　　根據提示啟動項目：

$ cd luffy_project/
$ npm run dev

　　由於在初始化時選擇了vue-router，因此會自動創建/src/router/index.js文件。

　　刪除Helloworld組件相關信息后，index.js文件內容如下所示：

import Vue from 'vue'
import Router from 'vue-router'
// @絕對路徑 檢索到 ...src/

// 如果Router當做局部模塊使用一定要Vue.use(Router)
// 以後在組件中，可以通過this.$router 獲取Router實例化對象
// 路由信息對象 this.$routes 獲取路由配置信息
Vue.use(Router)

// 配置路由規則
export default new Router({
  routes: [
    {
      'path': '/'
    }
  ]
})

二、基於ElementUI框架實現導航欄

1、elementUI——適合Vue的UI框架

　　elementUI是一個UI庫，它不依賴於vue，但確是當前和vue配合做項目開發的一個比較好的UI框架。

（1）npm安裝

　　推薦使用 npm 的方式安裝，能更好地和 webpack 打包工具配合使用。

$ npm i element-ui -S

（2）CDN

　　目前可以通過 unpkg.com/element-ui 獲取到最新版本的資源，在頁面上引入 js 和 css 文件即可開始使用。

<!-- 引入樣式 -->
<link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
<!-- 引入組件庫 -->
<script src="https://unpkg.com/element-ui/lib/index.js"></script>

　　使用CND引入 Element 需要在鏈接地址上鎖定版本，以免將來 Element 升級時受到非兼容性更新的影響。鎖定版本的方法請查看 unpkg.com。

2、引入 Element

　　在項目中可以引入整個Element，或者是根據需要僅引入部分組件。

（1）完整引入

　　在 main.js 中寫入如下內容：

import Vue from 'vue'
import App from './App'
import router from './router'
// elementUI導入
import ElementUI from 'element-ui'
import 'element-ui/lib/theme-chalk/index.css'  // 注意樣式文件需要單獨引入
// 調用插件
Vue.use(ElementUI);

Vue.config.productionTip = false;

/* eslint-disable no-new */
new Vue({
  el: '#app',
  router,
  components: { App },
  template: '<App/>'
});

　　以上代碼便完成了 Element 的完整引入。

　　嘗試在App.vue使用elementui的Button按鈕：

<template>
  <div id="app">
    <!-- 導航區域 -->
    <el-button type="info">信息按鈕</el-button>

    <router-view/>
  </div>
</template>

<script>
export default {
  name: 'App'
}
</script>

　　显示效果：

　　 

（2）按需引入

　　藉助 babel-plugin-component，可以只引入需要的組件，以達到減小項目體積的目的。

　　首先安裝babel-plugin-component：

$ npm install babel-plugin-component -D

　　然後將.babelrc文件修改如下：

{
  "presets": [["es2015", { "modules": false }]],
  "plugins": [
    [
      "component",
      {
        "libraryName": "element-ui",
        "styleLibraryName": "theme-chalk"
      }
    ]
  ]
}

　　如果只希望引入部分組件，如Buttion何Select，那麼需要在 main.js 中寫如下內容：

import Vue from 'vue';
import { Button, Select } from 'element-ui';
import App from './App.vue';

Vue.component(Button.name, Button);
Vue.component(Select.name, Select);
/* 或寫為
 * Vue.use(Button)
 * Vue.use(Select)
 */

new Vue({
  el: '#app',
  render: h => h(App)
});

3、導航欄實現

　　首先創建/src/components/Common/LuffyHeader.vue文件：

<template>
  <!-- element-ui -->
  <el-container>
    <el-header height = '80px' >
      <div class="header">
        <div class="nav-left">
          <img src="https://www.luffycity.com/static/img/head-logo.a7cedf3.svg" alt="">
        </div>
        <div class="nav-center">
          <ul>
            <li>
              <a href="#">
                導航鏈接
              </a>
            </li>
          </ul>
        </div>
        <div class="nav-right">
          <span>登錄</span>
          &nbsp;| &nbsp;
          <span>註冊</span>
        </div>
      </div>
    </el-header>
  </el-container>
</template>

<script>
  export default {
    name: 'LuffyHeader',
    data(){
      return {
      }
    },
  };
</script>

　　再創建/static/global/global.css文件：

* {
  padding: 0;
  margin: 0;
}

body {
  font-size: 14px;
  color: #4a4a4a;
  font-family: PingFangSC-Light; /*蘋果設計的一款全新的中文系統字體，該字體支持蘋果的動態字體調節技術*/
}

ul {
  list-style: none;
}

a {
  text-decoration: none;
}

　　最後在App.vue中引入和使用組件：

<template>
  <div id="app">
    <!-- 導航區域 -->
    <LuffyHeader/>
    <router-view/>
  </div>
</template>

<script>
  import LuffyHeader from '@/components/Common/LuffyHeader'
  export default {
    name: 'App',
    components:{
      LuffyHeader
    }
  }
</script>

　　显示效果如下所示：

　　

三、導航欄路由跳轉

1、組件創建和路由配置編寫

　　添加“首頁”、“免費課程”、“輕課”、“學位課”四大組件，因此創建如下文件：

src/components/Home/Home.vue
src/components/Course/Course.vue
src/components/LightCourse/LightCourse.vue
src/components/Micro/Micro.vue

　　在src/router/index.js中引入組件，配置路由規則：

import Vue from 'vue'
import Router from 'vue-router'
// @絕對路徑 檢索到 ...src/

// 如果Router當做局部模塊使用一定要Vue.use(Router)
// 以後在組件中，可以通過this.$router 獲取Router實例化對象
// 路由信息對象 this.$routes 獲取路由配置信息
import Home from '@/components/Home/Home'
import Course from '@/components/Course/Course'
import LightCourse from '@/components/LightCourse/LightCourse'
import Micro from '@/components/Micro/Micro'

Vue.use(Router)

// 配置路由規則
export default new Router({
  routes: [
    {
      path: '/',
      redirect: '/home'   // 訪問/，直接跳轉到/home路徑
    },
    {
      path: '/home',
      name: 'Home',
      component: Home
    },
    {
      path: '/course',
      name: 'Course',
      component: Course
    },
    {
      path: '/home/light-course',
      name: 'LightCourse',
      component: LightCourse
    },
    {
      path: '/micro',
      name: 'Micro',
      component: Micro
    }
  ]
})

2、導航鏈接編寫

　　修改 LuffyHeader.vue頁面，編寫導航鏈接：

<template>
  <!-- element-ui -->
  <el-container>
    <el-header height = '80px' >
      <div class="header">
        <div class="nav-left">
          <img src="https://www.luffycity.com/static/img/head-logo.a7cedf3.svg" alt="">
        </div>
        <div class="nav-center">
          <ul>
            <li v-for="(list, index) in headerList" :key="list.id">
              <a href="#">
                {{ list.title }}
              </a>
            </li>
          </ul>
        </div>
        <div class="nav-right">
          <span>登錄</span>
          &nbsp;| &nbsp;
          <span>註冊</span>
        </div>
      </div>
    </el-header>
  </el-container>
</template>

<script>
  export default {
    name: 'LuffyHeader',
    data() {
      return {
        headerList: [
          {id: '1', name: 'Home', title: '首頁'},
          {id: '2', name: 'Course', title: '免費課程'},
          {id: '3', name: 'LightCourse', title: '輕課'},
          {id: '4', name: 'Micro', title: '學位課程'}
        ],
        isShow: false
      }
    }
  }
</script>

　　編寫headerList列表及列表中的導航對象，在 導航欄中遍歷對象獲取對應信息，显示在頁面效果如下所示：

　　

3、router-link路由跳轉

　　經過上面的編寫，雖然導航欄已經可以正常显示，但是a標籤是不會做自動跳轉的。 需要使用 router-link 進一步改寫LuffyHeader.vue，使得路由跳轉得以渲染對應組件：

<template>
  <!-- element-ui -->
  <el-container>
    <el-header height = '80px' >
      <div class="header">
        <div class="nav-left">
          <img src="https://www.luffycity.com/static/img/head-logo.a7cedf3.svg" alt="">
        </div>
        <div class="nav-center">
          <ul>
            <li v-for="(list, index) in headerList" :key="list.id">
              <router-link :to="{name:list.name}">
                {{ list.title }}
              </router-link>
            </li>
          </ul>
        </div>
        <div class="nav-right">
          <span>登錄</span>
          &nbsp;| &nbsp;
          <span>註冊</span>
        </div>
      </div>
    </el-header>
  </el-container>
</template>

<script>
  export default {
    name: 'LuffyHeader',
    data() {
      return {
        headerList: [
          {id: '1', name: 'Home', title: '首頁'},
          {id: '2', name: 'Course', title: '免費課程'},
          {id: '3', name: 'LightCourse', title: '輕課'},
          {id: '4', name: 'Micro', title: '學位課程'}
        ],
        isShow: false
      }
    }
  }
</script>

　　使用to='{name:list.name}’設置命令路由，這樣點擊a標籤就可以跳轉了。显示效果如下所示：

　　

　　可以看到雖然點擊了輕課，但是和其他導航項樣式沒有任何分別，需要設置路由active樣式完成優化。

4、linkActiveClass設置路由的active樣式

　　linkActiveClass 全局配置 <router-link> 的默認“激活 class 類名”。

　　active-class 設置 鏈接激活時使用的 CSS 類名。默認值可以通過路由的構造選項 linkActiveClass 來全局配置。

（1）在路由配置linkActiveClass

　　在 src/router/index.js 中做如下配置：

import Vue from 'vue'
import Router from 'vue-router'
// @絕對路徑 檢索到 ...src/

// 如果Router當做局部模塊使用一定要Vue.use(Router)
// 以後在組件中，可以通過this.$router 獲取Router實例化對象
// 路由信息對象 this.$routes 獲取路由配置信息
import Home from '@/components/Home/Home'
import Course from '@/components/Course/Course'
import LightCourse from '@/components/LightCourse/LightCourse'
import Micro from '@/components/Micro/Micro'

Vue.use(Router)

// 配置路由規則
export default new Router({
  linkActiveClass: 'is-active',
  routes: [
    {
      path: '/',
      redirect: '/home'   // 訪問/，直接跳轉到/home路徑
    },
    ......
    {
      path: '/micro',
      name: 'Micro',
      component: Micro
    }
  ]
})

（2）在LuffyHeader.vue中配置路由active樣式

<template>
  ......省略
</template>

<script>
  ......省略
</script>

<style lang="css" scoped>
  .nav-center ul li a.is-active{
    color: #4a4a4a;
    border-bottom: 4px solid #ffc210;
  }
</style>

（3）显示效果

　　

5、hash模式切換為 history 模式

　　vue-router 默認 hash 模式——使用URL的hash來模擬一個完整的URL，於是當URL改變時，頁面不會重新加載。比如http://www.abc.com/#/index，hash值為#/index。hash模式的特點在於hash出現在url中，但是不會被包括在HTTP請求中，對後端沒有影響，不會重新加載頁面。

　　如果不想要這種显示比較丑的hash，可以用路由的 history模式，這種模式充分利用 history.pushState API來完成URL跳轉而無需重新加載頁面。

（1）路由修改為history模式

　　修改 src/router/index.js 文件如下所示：

import Vue from 'vue'
import Router from 'vue-router'
// @絕對路徑 檢索到 ...src/

// 如果Router當做局部模塊使用一定要Vue.use(Router)
// 以後在組件中，可以通過this.$router 獲取Router實例化對象
// 路由信息對象 this.$routes 獲取路由配置信息
import Home from '@/components/Home/Home'
import Course from '@/components/Course/Course'
import LightCourse from '@/components/LightCourse/LightCourse'
import Micro from '@/components/Micro/Micro'

Vue.use(Router)

// 配置路由規則
export default new Router({
  linkActiveClass: 'is-active',
  mode: 'history',   // 改為history模式
  routes: [
    {
      path: '/',
      redirect: '/home'   // 訪問/，直接跳轉到/home路徑
    },
    .....
  ]
})

　　使用history模式時，url就像正常url，例如http://yoursite.com/user/id，這樣比較美觀。

　　显示效果如下所示：

　　

（2）後端配置

　　 但是要用好這種模式，需要後台配置支持。vue的應用是單頁客戶端應用，如果後台沒有正確的配置，用戶在瀏覽器訪問http://yoursite.com/user/id 就會返回404，這樣就不好了。

　　因此要在服務端增加一個覆蓋所有情況的候選資源：如果 URL 匹配不到任何靜態資源，則應該返回同一個 index.html 頁面，這個頁面就是app依賴的頁面。

　　後端配置示例：https://router.vuejs.org/zh/guide/essentials/history-mode.html#%E5%90%8E%E7%AB%AF%E9%85%8D%E7%BD%AE%E4%BE%8B%E5%AD%90

 

【精選推薦文章】

如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

想要讓你的商品在網路上成為最夯、最多人討論的話題?

網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師"嚨底家"!!