為更良好的閱讀體驗，請訪問原文：

一、前言

當我們使用計算機時，可以同時做許多事情，例如一邊打遊戲一邊聽音樂。這是因為操作系統支持併發任務，從而使得這些工作得以同時進行。

• 那麼提出一個問題：如果我們要實現一個程序能一邊聽音樂一邊玩遊戲怎麼實現呢？

public class Tester {

    public static void main(String[] args) {
        System.out.println("開始....");
        playGame();
        playMusic();
        System.out.println("結束....");
    }

    private static void playGame() {
        for (int i = 0; i < 50; i++) {
            System.out.println("玩遊戲" + i);
        }
    }

    private static void playMusic() {
        for (int i = 0; i < 50; i++) {
            System.out.println("播放音樂" + i);
        }
    }
}

我們使用了循環來模擬過程，因為播放音樂和打遊戲都是連續的，但是結果卻不盡人意，因為函數體總是要執行完之後才能返回。那麼到底怎麼解決這個問題？

并行與併發

并行性和併發性是既相似又有區別的兩個概念。

并行性是指兩個或多個事件在同一時刻發生。而併發性是指兩個或多個事件在同一時間間隔內發生。

在多道程序環境下，併發性是指在一段時間內宏觀上有多個程序在同時運行，但在單處理機環境下（一個處理器），每一時刻卻僅能有一道程序執行，故微觀上這些程序只能是分時地交替執行。例如，在 1 秒鐘時間內，0 – 15 ms 程序 A 運行；15 – 30 ms 程序 B 運行；30 – 45 ms 程序 C 運行；45 – 60 ms 程序 D 運行，因此可以說，在 1 秒鐘時間間隔內，宏觀上有四道程序在同時運行，但微觀上，程序 A、B、C、D 是分時地交替執行的。

如果在計算機系統中有多個處理機，這些可以併發執行的程序就可以被分配到多個處理機上，實現併發執行，即利用每個處理機愛處理一個可併發執行的程序。這樣，多個程序便可以同時執行。以此就能提高系統中的資源利用率，增加系統的吞吐量。

進程和線程

進程是指一個內存中運行的應用程序。一個應用程序可以同時啟動多個進程，那麼上面的問題就有了解決的思路：我們啟動兩個進程，一個用來打遊戲，一個用來播放音樂。這當然是一種解決方案，但是想象一下，如果一個應用程序需要執行的任務非常多，例如 LOL 遊戲吧，光是需要播放的音樂就有非常多，人物本身的語音，技能的音效，遊戲的背景音樂，塔攻擊的聲音等等等，還不用說遊戲本身，就光播放音樂就需要創建許多許多的進程，而進程本身是一種非常消耗資源的東西，這樣的設計顯然是不合理的。更何況大多數的操作系統都不需要一個進程訪問其他進程的內存空間，也就是說，進程之間的通信很不方便，此時我們就得引入“線程”這門技術，來解決這個問題。

線程是指進程中的一個執行任務（控制單元），一個進程可以同時併發運行多個線程。我們可以打開任務管理器，觀察到幾乎所有的進程都擁有着許多的「線程」(在 WINDOWS 中線程是默認隱藏的，需要在「查看」裏面點擊「選擇列」，有一個線程數的勾選項，找到並勾選就可以了)。

進程和線程的區別

進程：有獨立的內存空間，進程中的數據存放空間（堆空間和棧空間）是獨立的，至少有一個線程。

線程：堆空間是共享的，棧空間是獨立的，線程消耗的資源也比進程小，相互之間可以影響的，又稱為輕型進程或進程元。

因為一個進程中的多個線程是併發運行的，那麼從微觀角度上考慮也是有先後順序的，那麼哪個線程執行完全取決於 CPU 調度器(JVM 來調度)，程序員是控制不了的。我們可以把多線程併發性看作是多個線程在瞬間搶 CPU 資源，誰搶到資源誰就運行，這也造就了多線程的隨機性。下面我們將看到更生動的例子。

Java 程序的進程(Java 的一個程序運行在系統中)里至少包含主線程和垃圾回收線程(後台線程)，你可以簡單的這樣認為，但實際上有四個線程（了解就好）：

• [1] main——main 線程，用戶程序入口
• [2] Reference Handler——清除 Reference 的線程
• [3] Finalizer——調用對象 finalize 方法的線程
• [4] Signal Dispatcher——分發處理髮送給 JVM 信號的線程

多線程和單線程的區別和聯繫？

1. 單核 CPU 中，將 CPU 分為很小的時間片，在每一時刻只能有一個線程在執行，是一種微觀上輪流佔用 CPU 的機制。

2. 多線程會存在線程上下文切換，會導致程序執行速度變慢，即採用一個擁有兩個線程的進程執行所需要的時間比一個線程的進程執行兩次所需要的時間要多一些。

結論：即採用多線程不會提高程序的執行速度，反而會降低速度，但是對於用戶來說，可以減少用戶的響應時間。

多線程的優勢

儘管面臨很多挑戰，多線程有一些優點仍然使得它一直被使用，而這些優點我們應該了解。

優勢一：資源利用率更好

想象一下，一個應用程序需要從本地文件系統中讀取和處理文件的情景。比方說，從磁盤讀取一個文件需要 5 秒，處理一個文件需要 2 秒。處理兩個文件則需要：

1| 5秒讀取文件A
2| 2秒處理文件A
3| 5秒讀取文件B
4| 2秒處理文件B
5| ---------------------
6| 總共需要14秒

從磁盤中讀取文件的時候，大部分的 CPU 時間用於等待磁盤去讀取數據。在這段時間里，CPU 非常的空閑。它可以做一些別的事情。通過改變操作的順序，就能夠更好的使用 CPU 資源。看下面的順序：

1| 5秒讀取文件A
2| 5秒讀取文件B + 2秒處理文件A
3| 2秒處理文件B
4| ---------------------
5| 總共需要12秒

CPU 等待第一個文件被讀取完。然後開始讀取第二個文件。當第二文件在被讀取的時候，CPU 會去處理第一個文件。記住，在等待磁盤讀取文件的時候，CPU 大部分時間是空閑的。

總的說來，CPU 能夠在等待 IO 的時候做一些其他的事情。這個不一定就是磁盤 IO。它也可以是網絡的 IO，或者用戶輸入。通常情況下，網絡和磁盤的 IO 比 CPU 和內存的 IO 慢的多。

優勢二：程序設計在某些情況下更簡單

在單線程應用程序中，如果你想編寫程序手動處理上面所提到的讀取和處理的順序，你必須記錄每個文件讀取和處理的狀態。相反，你可以啟動兩個線程，每個線程處理一個文件的讀取和操作。線程會在等待磁盤讀取文件的過程中被阻塞。在等待的時候，其他的線程能夠使用 CPU 去處理已經讀取完的文件。其結果就是，磁盤總是在繁忙地讀取不同的文件到內存中。這會帶來磁盤和 CPU 利用率的提升。而且每個線程只需要記錄一個文件，因此這種方式也很容易編程實現。

優勢三：程序響應更快

有時我們會編寫一些較為複雜的代碼（這裏的複雜不是說複雜的算法，而是複雜的業務邏輯），例如，一筆訂單的創建，它包括插入訂單數據、生成訂單趕快找、發送郵件通知賣家和記錄貨品銷售數量等。用戶從單擊“訂購”按鈕開始，就要等待這些操作全部完成才能看到訂購成功的結果。但是這麼多業務操作，如何能夠讓其更快地完成呢？

在上面的場景中，可以使用多線程技術，即將數據一致性不強的操作派發給其他線程處理（也可以使用消息隊列），如生成訂單快照、發送郵件等。這樣做的好處是響應用戶請求的線程能夠盡可能快地處理完成，縮短了響應時間，提升了用戶體驗。

其他優勢

多線程還有一些優勢也顯而易見：

• 進程之前不能共享內存，而線程之間共享內存(堆內存)則很簡單。
• 系統創建進程時需要為該進程重新分配系統資源,創建線程則代價小很多,因此實現多任務併發時,多線程效率更高.
• Java 語言本身內置多線程功能的支持,而不是單純地作為底層系統的調度方式,從而簡化了多線程編程.

上下文切換

即使是單核處理器也支持多線程執行代碼，CPU 通過給每個線程分配 CPU 時間片來實現這個機制。時間片是 CPU 分配給各個線程的時間，因為時間片非常短，所以 CPU 通過不停地切換線程執行，讓我們感覺多個線程是同時執行的，時間片一般是幾十毫秒（ms）。

CPU 通過時間片分配算法來循環執行任務，當前任務執行一個時間片後會切換到下一個任務。但是，在切換前會保存上一個任務的狀態，以便下次切換回這個任務的時候，可以再加載這個任務的狀態。所以任務從保存到再加載的過程就是一次上下文切換。

這就像我們同時讀兩本書，當我們在讀一本英文的技術書時，發現某個單詞不認識，於是打開中英文字典，但是在放下英文技術書之前，大腦必須先記住這本書獨到了多少頁的多少行，等查完單詞之後，能夠繼續讀這本書。這樣的切換是會影響讀書效率的，同樣上下文切換也會影響多線程的執行速度。

二、創建線程的兩種方式

繼承 Thread 類

public class Tester {

    // 播放音樂的線程類
    static class PlayMusicThread extends Thread {

        // 播放時間，用循環來模擬播放的過程
        private int playTime = 50;

        public void run() {
            for (int i = 0; i < playTime; i++) {
                System.out.println("播放音樂" + i);
            }
        }
    }

    // 方式1：繼承 Thread 類
    public static void main(String[] args) {
        // 主線程：運行遊戲
        for (int i = 0; i < 50; i++) {
            System.out.println("打遊戲" + i);
            if (i == 10) {
                // 創建播放音樂線程
                PlayMusicThread musicThread = new PlayMusicThread();
                musicThread.start();
            }
        }
    }
}

運行結果發現打遊戲和播放音樂交替出現，說明已經成功了。

實現 Runnable 接口

public class Tester {

    // 播放音樂的線程類
    static class PlayMusicThread implements Runnable {

        // 播放時間，用循環來模擬播放的過程
        private int playTime = 50;

        public void run() {
            for (int i = 0; i < playTime; i++) {
                System.out.println("播放音樂" + i);
            }
        }
    }

    // 方式2：實現 Runnable 方法
    public static void main(String[] args) {
        // 主線程：運行遊戲
        for (int i = 0; i < 50; i++) {
            System.out.println("打遊戲" + i);
            if (i == 10) {
                // 創建播放音樂線程
                Thread musicThread = new Thread(new PlayMusicThread());
                musicThread.start();
            }
        }
    }
}

也能完成效果。

以上就是傳統的兩種創建線程的方式，事實上還有第三種，我們後邊再講。

多線程一定快嗎？

先來一段代碼，通過并行和串行來分別執行累加操作，分析：下面的代碼併發執行一定比串行執行快嗎？

import org.springframework.util.StopWatch;

// 比較并行和串行執行累加操作的速度
public class Tester {

    // 執行次數
    private static final long COUNT = 100000000;
    private static final StopWatch TIMER = new StopWatch();

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
        // 打印比較測試結果
        System.out.println(TIMER.prettyPrint());
    }

    private static void serial() {
        TIMER.start("串行執行" + COUNT + "條數據");

        int a = 0;
        for (long i = 0; i < COUNT; i++) {
            a += 5;
        }
        // 串行執行
        int b = 0;
        for (long i = 0; i < COUNT; i++) {
            b--;
        }

        TIMER.stop();
    }

    private static void concurrency() throws InterruptedException {
        TIMER.start("并行執行" + COUNT + "條數據");

        // 通過匿名內部類來創建線程
        Thread thread = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a += 5;
            }
        });
        thread.start();

        // 并行執行
        int b = 0;
        for (long i = 0; i < COUNT; i++) {
            b--;
        }
        // 等待線程結束
        thread.join();
        TIMER.stop();
    }
}

大家可以自己測試一下，每一台機器 CPU 不同測試結果可能也會不同，之前在 WINDOWS 本兒上測試的時候，多線程的優勢從 1 千萬數據的時候才開始體現出來，但是現在換了 MAC，1 億條數據時間也差不多，到 10 億的時候明顯串行就比并行快了… 總之，為什麼併發執行的速度會比串行慢呢？就是因為線程有創建和上下文切換的開銷。

繼承 Thread 類還是實現 Runnable 接口？

想象一個這樣的例子：給出一共 50 個蘋果，讓三個同學一起來吃，並且給蘋果編上號碼，讓他們吃的時候順便要說出蘋果的編號：

運行結果可以看到，使用繼承方式實現，每一個線程都吃了 50 個蘋果。這樣的結果顯而易見：是因為顯式地創建了三個不同的 Person 對象，而每個對象在堆空間中有獨立的區域來保存定義好的 50 個蘋果。

而使用實現方式則滿足要求，這是因為三個線程共享了同一個 Apple 對象，而對象中的 num 數量是一定的。

所以可以簡單總結出繼承方式和實現方式的區別：

繼承方式：

1. Java 中類是單繼承的，如果繼承了 Thread 了，該類就不能再有其他的直接父類了；
2. 從操作上分析，繼承方式更簡單，獲取線程名字也簡單..(操作上，更簡單)
3. 從多線程共享同一個資源上分析，繼承方式不能做到…

實現方式：

1. Java 中類可以實現多個接口，此時該類還可以繼承其他類，並且還可以實現其他接口(設計上，更優雅)..
2. 從操作上分析，實現方式稍微複雜點，獲取線程名字也比較複雜，需要使用 Thread.currentThread() 來獲取當前線程的引用..
3. 從多線程共享同一個資源上分析，實現方式可以做到..

在這裏，三個同學完成搶蘋果的例子，使用實現方式才是更合理的方式。

對於這兩種方式哪種好並沒有一個確定的答案，它們都能滿足要求。就我個人意見，我更傾向於實現 Runnable 接口這種方法。因為線程池可以有效的管理實現了 Runnable 接口的線程，如果線程池滿了，新的線程就會排隊等候執行，直到線程池空閑出來為止。而如果線程是通過實現 Thread 子類實現的，這將會複雜一些。

有時我們要同時融合實現 Runnable 接口和 Thread 子類兩種方式。例如，實現了 Thread 子類的實例可以執行多個實現了 Runnable 接口的線程。一個典型的應用就是線程池。

常見錯誤：調用 run() 方法而非 start() 方法

創建並運行一個線程所犯的常見錯誤是調用線程的 run() 方法而非 start() 方法，如下所示：

1| Thread newThread = new Thread(MyRunnable());
2| newThread.run();  //should be start();

起初你並不會感覺到有什麼不妥，因為 run() 方法的確如你所願的被調用了。但是，事實上，run() 方法並非是由剛創建的新線程所執行的，而是被創建新線程的當前線程所執行了。也就是被執行上面兩行代碼的線程所執行的。想要讓創建的新線程執行 run() 方法，必須調用新線程的 start() 方法。

三、線程的安全問題

吃蘋果遊戲的不安全問題

我們來考慮一下上面吃蘋果的例子，會有什麼問題？

儘管，Java 並不保證線程的順序執行，具有隨機性，但吃蘋果比賽的案例運行多次也並沒有發現什麼太大的問題。這並不是因為程序沒有問題，而只是問題出現的不夠明顯，為了讓問題更加明顯，我們使用 Thread.sleep() 方法（經常用來模擬網絡延遲）來讓線程休息 10 ms，讓其他線程去搶資源。（注意：在程序中並不是使用 Thread.sleep(10)之後,程序才出現問題,而是使用之後,問題更明顯.）

為什麼會出現這樣的錯誤呢？

先來分析第一種錯誤：為什麼會吃重複的蘋果呢？就拿 B 和 C 都吃了編號為 47 的蘋果為例吧：

• A 線程拿到了編號為 48 的蘋果，打印輸出然後讓 num 減 1，睡眠 10 ms，此時 num 為 47。
• 這時 B 和 C 同時都拿到了編號為 47 的蘋果，打印輸出，在其中一個線程作出了減一操作的時候，A 線程從睡眠中醒過來，拿到了編號為 46 的蘋果，然後輸出。在這期間並沒有任何操作不允許 B 和 C 線程不能拿到同一個編號的蘋果，之前沒有明顯的錯誤僅僅可能只是因為運行速度太快了。

再來分析第二種錯誤：照理來說只應該存在 1-50 編號的蘋果，可是 0 和-1 是怎麼出現的呢？

• 當 num = 1 的時候，A，B，C 三個線程同時進入了 try 語句進行睡眠。
• C 線程先醒過來，輸出了編號為 1 的蘋果，然後讓 num 減一，當 C 線程醒過來的時候發現 num 為 0 了。
• A 線程醒過來一看，0 都沒有了，只有 -1 了。

歸根結底是因為沒有任何操作來限制線程來獲取相同的資源並對他們進行操作，這就造成了線程安全性問題。

如果我們把打印和減一的操作分成兩個步驟，會更加明顯：

ABC 三個線程同時打印了 50 的蘋果，然後同時做出減一操作。

像這樣的原子操作，是不允許分步驟進行的，必須保證同步進行，不然可能會引發不可設想的後果。

要解決上述多線程併發訪問一個資源的安全性問題，就需要引入線程同步的概念。

線程同步

多個執行線程共享一個資源的情景，是最常見的併發編程情景之一。為了解決訪問共享資源錯誤或數據不一致的問題，人們引入了臨界區的概念：用以訪問共享資源的代碼塊，這個代碼塊在同一時間內只允許一個線程執行。

為了幫助編程人員實現這個臨界區，Java（以及大多數編程語言）提供了同步機制，當一個線程試圖訪問一個臨界區時，它將使用一種同步機制來查看是不是已經有其他線程進入臨界區。如果沒有其他線程進入臨界區，他就可以進入臨界區。如果已經有線程進入了臨界區，它就被同步機制掛起，直到進入的線程離開這個臨界區。如果在等待進入臨界區的線程不止一個，JVM 會選擇其中的一個，其餘的將繼續等待。

synchronized 關鍵字

如果一個對象已用 synchronized 關鍵字聲明，那麼只有一個執行線程被允許訪問它。使用 synchronized 的好處顯而易見：保證了多線程併發訪問時的同步操作，避免線程的安全性問題。但是壞處是：使用 synchronized 的方法/代碼塊的性能比不用要低一些。所以好的做法是：盡量減小 synchronized 的作用域。

我們還是先來解決吃蘋果的問題，考慮一下 synchronized 關鍵字應該加在哪裡呢？

發現如果還再把 synchronized 關鍵字加在 if 裏面的話，0 和 -1 又會出來了。這其實是因為當 ABC 同是進入到 if 語句中，等待臨界區釋放的時，拿到 1 編號的線程已經又把 num 減一操作了，而此時最後一個等待臨界區的進程拿到的就會是 -1 了。

同步鎖 Lock

Lock 機制提供了比 synchronized 代碼塊和 synchronized 方法更廣泛的鎖定操作，同步代碼塊/ 同步方法具有的功能 Lock 都有，除此之外更強大，更體現面向對象。在併發包的類族中，Lock 是 JUC 包的頂層接口，它的實現邏輯並未用到 synchronized，而是利用了 volatile 的可見性。

使用 Lock 最典型的代碼如下：

class X {

    private final ReentrantLock lock = new ReentrantLock();

    public void m() {
        lock.lock();
        try {
            // ..... method body
        } finally {
            lock.unlock();
        }
    }
}

線程安全問題

線程安全問題只在多線程環境下才會出現，單線程串行執行不存在此類問題。保證高併發場景下的線程安全，可以從以下四個維度考量：

維度一：數據單線程可見

單線程總是安全的。通過限制數據僅在單線程內可見，可以避免數據被其他線程篡改。最典型的就是線程局部變量，它存儲在獨立虛擬機棧幀的局部變量表中，與其他線程毫無瓜葛。TreadLocal 就是採用這種方式來實現線程安全的。

維度二：只讀對象

只讀對象總是安全的。它的特性是允許複製、拒絕寫入。最典型的只讀對象有 String、Integer 等。一個對象想要拒絕任何寫入，必須要滿足以下條件：

• 使用 final 關鍵字修飾類，避免被繼承；
• 使用 private final 關鍵字避免屬性被中途修改；
• 沒有任何更新方法；
• 返回值不能為可變對象。

維度三：線程安全類

某些線程安全類的內部有非常明確的線程安全機制。比如 StringBuffer 就是一個線程安全類，它採用 synchronized 關鍵字來修飾相關方法。

維度四：同步與鎖機制

如果想要對某個對象進行併發更新操作，但又不屬於上述三類，需要開發工程師在代碼中實現安全的同步機制。雖然這個機制支持的併發場景很有價值，但非常複雜且容易出現問題。

處理線程安全的核心理念

要麼只讀，要麼加鎖。

合理利用好 JDK 提供的併發包，往往能化腐朽為神奇。Java 併發包（java.util.concurrent，JUC）中大多數類註釋都寫有：@author Doug Lea。如果說 Java 是一本史書，那麼 Doug Lea 絕對是開疆拓土的偉大人物。Doug Lea 在當大學老師時，專攻併發編程和併發數據結構設計，主導設計了 JUC 併發包，提高了 Java 併發編程的易用性，大大推進了 Java 的商用進程。

參考資料

• 《Java 零基礎入門教程》 –
• 《Java 併發編程的藝術》
• 《Java 7 併發編程實戰手冊》
• 《碼出高效 Java 開發手冊》 – 楊冠寶（孤盡） 高海慧（鳴莎）著

按照慣例黏一個尾巴：

歡迎轉載，轉載請註明出處！
獨立域名博客：wmyskxz.com
簡書 ID：
github：
歡迎關注公眾微信號：wmyskxz
分享自己的學習 & 學習資料 & 生活
想要交流的朋友也可以加 qq 群：3382693

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

很多人覺得Spring Security實現登錄驗證很難，我最開始學習的時候也這樣覺得。因為我好久都沒看懂我該怎麼樣將自己寫的用於接收用戶名密碼的Controller與Spring Security結合使用，這是一個先入為主的誤區。後來我搞懂了：根本不用你自己去寫Controller。你只需要告訴Spring Security用戶信息、角色信息、權限信息、登錄頁是什麼？登陸成功頁是什麼？或者其他有關登錄的一切信息。具體的登錄驗證邏輯它來幫你實現。

一、動態數據登錄驗證的基礎知識

在本號之前的文章中，已經介紹了Spring Security的formLogin登錄認證模式，RBAC的權限控制管理模型，並且針對Spring Security的登錄認證邏輯源碼進行了解析等等。我們所有的用戶、角色、權限信息都是在配置文件裏面寫死的，然而在實際的業務系統中，這些信息通常是存放在RBAC權限模型的數據庫表中的。下面我們來回顧一下其中的核心概念：

• RBAC的權限模型可以從用戶獲取為用戶分配的一個或多個角色，從用戶的角色又可以獲取該角色的多種權限。通過關聯查詢可以獲取某個用戶的角色信息和權限信息。
• 在源碼解析的文章中，我們知道如果我們不希望用戶、角色、權限信息寫死在配置裏面。我們應該實現UserDetails與UserDetailsService接口，從而從數據庫或者其他的存儲上動態的加載這些信息。

以上是對一些核心的基礎知識的總結，如果您對這些知識還不是很清晰，建議您先往下讀本文。如果看完本文仍然理解困難，建議您翻看本號之前的文章。

二、UserDetails與UserDetailsService接口

• UserDetailsService接口有一個方法叫做loadUserByUsername，我們實現動態加載用戶、角色、權限信息就是通過實現該方法。函數見名知義：通過用戶名加載用戶。該方法的返回值就是UserDetails。
• UserDetails就是用戶信息，即：用戶名、密碼、該用戶所具有的權限。

下面我們來看一下UserDetails接口都有哪些方法。

public interface UserDetails extends Serializable {
    //獲取用戶的權限集合
    Collection<? extends GrantedAuthority> getAuthorities();

    //獲取密碼
    String getPassword();

    //獲取用戶名
    String getUsername();

    //賬號是否沒過期
    boolean isAccountNonExpired();

    //賬號是否沒被鎖定
    boolean isAccountNonLocked();

    //密碼是否沒過期
    boolean isCredentialsNonExpired();

    //賬戶是否可用
    boolean isEnabled();
}

現在，我們明白了，只要我們把這些信息提供給Spring Security，Spring Security就知道怎麼做登錄驗證了，根本不需要我們自己寫Controller實現登錄驗證邏輯。

三、實現UserDetails 接口

public class SysUser implements UserDetails{
    
    String password();  //密碼
    String username();  //用戶名
    boolean accountNonExpired;   //是否沒過期
    boolean accountNonLocked;   //是否沒被鎖定
    boolean credentialsNonExpired;  //是否沒過期
    boolean enabled;  //賬號是否可用
    Collection<? extends GrantedAuthority> authorities;  //用戶的權限集合

    //省略構造方法
    //省略set方法
    //省略get方法（即接口UserDetails的方法）
}

我們就是寫了一個適應於UserDetails的java POJO類，所謂的 UserDetails接口實現就是一些get方法。get方法由Spring Security調用，我們通過set方法或構造函數為 Spring Security提供UserDetails數據。

四、實現UserDetailsService接口

@Component
public class MyUserDetailsService implements UserDetailsService{

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            
       //這裏從數據庫sys_user表裡面查詢實體類對象。loadUser方法可使用Mybatis或JDBC或JPA自行實現。
       SysUser sysUser =  loadUser(username);   

        // 判斷用戶是否存在 
       if(user == null)  {  throw  new  UsernameNotFoundException("用戶名不存在");  }

       //從數據庫該用戶所有的角色信息，所有的權限標誌
       //遍歷所有的ROLE角色及所有的Authority權限（菜單、按鈕）。
       //用逗號分隔他們的唯一標誌，具體過程自行實現。
       sysUser.setAuthorities(
               AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_AMIN , system:user:delete"));
        
        //sysUser.setAccountNonLocked(true或false);
        return sysUser;
    }
}

• 通常數據庫表sys_user字段要和SysUser屬性一一對應，比如username、password、enabled。但是比如accountNonLocked字段用於登錄多次錯誤鎖定，但我們一般不會在表裡存是否鎖定，而是存一個鎖定時間字段。通過鎖定時間是否大於當前時間判斷賬號是否鎖定，所以實現過程中可以靈活做判斷並用好set方法，不必拘泥於一一對應的形式。
• 角色是一種特殊的權限，在Spring Security我們可以使用hasRole(角色標識)表達式判斷用戶是否具有某個角色，決定他是否可以做某個操作;通過hasAuthority(權限標識)表達式判斷是否具有某個操作權限。

五、最後說明

至此，我們將系統裏面的所有的用戶、角色、權限信息都通過UserDetailsService和UserDetails告知了Spring Security。但是多數朋友可能仍然不知道該怎樣實現登錄的功能，其實剩下的事情很簡單了：

• 寫一個登錄界面，寫一個登錄表單，表單使用post方法提交到默認的/login路徑
• 表單的用戶名、密碼字段名稱默認是username、password。
• 寫一個登錄成功之後的跳轉頁面，比如index.html

然後把這些信息通過配置方式告知Spring Security ，以上的配置信息名稱都可以靈活修改。如果您不知道如何配置請參考本號之前的文章《formLogin登錄認證模式》。

期待您的關注

• 向您推薦博主的系列文檔：
• 本文轉載註明出處（必須帶連接，不能只轉文字）：。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

特斯拉上週發表了最新車種 Cybertruck，破格的外型與性能讓全球傻眼，本篇文章將告訴你 Cybertruck 設計成這樣的 6 個理由，以及 5 個它尚未說清楚的疑點。

老派科幻電影的線條、全車冷鑄不鏽鋼、跑得比保時捷還快、拉得比福特還給力，特斯拉 Cybertruck 一出場就奪走全世界目光，如同特斯拉執行長馬斯克（Elon Musk）說的，他要改變皮卡車一成不變的外觀。改變歸改變，改成這樣確實是有點誇張了，但 Cybertruck 在設計時，是遵循著以下 6 個原則，才會長成這樣。

1. 原則一：強悍外表
2. 原則二：將低風阻，提高效率
3. 原則三：內在舒適大空間
4. 原則四：適應不同路面駕駛
5. 原則五：大載貨量與拉力
6. 原則六：大電池容量

這些原則（或說是目標），部分來自於馬斯克個人的期待，一部分來自於市場調查的回饋，相信收到這個提案要求的專案，當下應該很想離職。但從發表會的成果來看，他們確實做到了。

為了看起來更強悍，Cybertruck 全車採用 301 不鏽鋼包覆。

皮卡車外表強悍，幾乎是一種固定形象，方方正正的大塊頭是百年傳統。但這樣的外表牴觸了原則二的低風阻要求，同時別忘了，低風阻的跑車，可不會配備原則三的車內大空間。

最終，結合這三項要求的最大公約數，原來就存在於 80 年代的科幻電影跟電玩中，當然這一切若沒有電動馬達是不可能達成的。燃油車的引擎通常配置於車頭，這是為了讓後方留出寬敞的乘坐空間，犧牲了車頭的流線設計，也在傳輸過程中浪費了部分動力。因此追求速度的跑車，通常將車頭壓低，引擎後置，這樣子減低了風阻，也讓動力傳導更直接，但是乘坐空間就非常狹窄，更別提燃油皮卡車後面的大型貨斗了。

Cybertruck 和目前越來越多的電動車一樣，將馬達、電池組整合在底盤，離輪胎更近，也讓上部空間更有彈性，Cybertruck 進一步運用了大眾對皮卡車車身較高的印象，讓它的底盤空間能塞進更多電池，還有其他黑科技，來滿足這些設計原則，像是適應性氣壓懸吊、龐大的電池容量以及可容納六人乘坐的車廂和一個可開閉的貨斗。

從試乘影片中，可以看到後座乘客（身高約 180 公分）在入座後，頭頂上仍然有兩個拳頭左右的空間，算是相當舒適，然而腿部空間似乎就比較侷促，後座寬度看起來和一般房車差不多，塞進兩位大漢剛剛好，整體來說，算是勉強達成了原則三的大空間要求。（官方數據，能容納 6 個成人）

但是，在完成這樣的設計之後，我們會發現，這種外觀線條看起來並不是那麼強悍，因為斜切的車頭讓人聯想到的是跑車，不是皮卡車或悍馬車這種硬漢風格。解決的辦法，就如同我們現在看到的，捨棄一般車輛的鈑金與烤漆，改用與姊妹公司 SpaceX 的太空船同樣材料的 301 不鏽鋼板，而且厚度達到 3 公厘，足以抵擋 9mm 口徑手槍的射擊。代價是，每一扇車門重達 27 公斤，萬一被車門夾到，後果可是不得了。

Cybertruck 內部空間比想像中寬闊，前方只有一塊 17 吋觸控螢幕作為主控台。

5 個等待揭開的疑問

發表會後隔天，馬斯克宣布訂單數量已經突破 14 萬，換句話說，這個發表會已經幫特斯拉賺進了 1,400 萬美元，然而這位愛做夢、愛說大話的老闆，心中也明白最後成交的數量可能不到一半，因為這台科幻裝甲車，仍然有幾個問題需要釐清。

問題一：後照鏡

許多人都發現了，發表會上的 Cybertruck 並沒有裝備車側後照鏡，官網上的影片與照片也都沒有看到，推測是使用攝影機來取代了傳統後照鏡，然而並非所有國家都開放電子後照鏡上路，包含美國跟台灣都還沒開放。在 Cybertruck 試乘的過程中，也沒看到螢幕上有播放左右後側的畫面，只有裝設數位正後方後照鏡，究竟 Cybertruck 怎麼解決車側後照鏡的問題，尚有待解答。

問題二：外觀塗裝

全不鏽鋼車身肯定會吸引到一部分的客群，但是正式販售時會不會提供不同款式的彩繪或是塗裝，並未說明，畢竟許多車主仍然希望自己的愛車能保有一些特殊性，至少花了 7 萬美元購買頂級款的車主，會希望自己的車看起來跟 4 萬美元的有些不同。

而提到外觀就不能不提那一整片乾乾淨淨的車頭，一般車輛會有車頭 Logo、進氣壩等，即使特斯拉其他車款，也都留有進氣孔，或許 Cybertruck 可以不用 Logo 來辨識，但是令人好奇的是它怎麼解決進氣的問題，又或者 Cybertruck 有了不同的方式來處理散熱和車內空氣流通問題

問題三：上下車

一般的皮卡車，車身都較高，對於家有老小的家庭來說，上下車會比較辛苦。從 Cybertruck 的照片中來看，底盤高度約在成年女子的膝蓋，算是有一點點難度。

在發表會上，Cybertruck 展示了它的適應性氣壓懸吊系統，在貨斗載重時，能夠自動調整車身高度；特斯拉官方也表示，當行駛於不同路面時，Cybertruck 會自動調整懸吊，在高速公路時會降低車身，在路面崎嶇時，會提高車身。這讓人不免想知道，當車主或乘客要上下車的時候，車身是否也會自動降低，方便進出呢？

問題四：貨斗操縱方式

市面上的皮卡車，後方貨斗大都是開放式的，也有車主會加裝棚罩，除了保護行李外，最重要是不讓路人亂丟垃圾。Cybertruck 的貨斗是機械式的，在發表會中，可以看到機車騎士走到車尾按了一些隱藏的開關，開啟貨斗，接著再用手拉開尾門，放下斜板。

特斯拉是否會將貨斗開閉設計得更容易使用呢？

對於一般卡車司機來說，這些動作稀鬆平常，但對於標榜高科技的 Cybertruck 來說，似乎不太「性感」，因此我們不免好奇，正式上市後，特斯拉是否會將操作貨斗開閉的功能，放到他們的手機 App 裡，讓車主可以更輕鬆地開關？

問題五：交車時間

最後的問題，也是特斯拉在過去幾年最為人詬病的問題，真的能夠如期交車嗎？特斯拉官網上寫得非常保守，「生產日期接近 2021 年底」，最高規格的三馬達版本，更是標明「預計在 2022 年底開始生產」。這等於是在說，我沒有說什麼時候交車，我只說了什麼時候開始製造，從生產到交車要多久，沒有人知道。

（合作媒體：。圖片來源：）

延伸閱讀：

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※公開收購3c價格,不怕被賤賣!

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

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

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

一、摘要

在集合系列的第一章，咱們了解到，Map 的實現類有 HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties 等等。

本文主要從數據結構和算法層面，探討 WeakHashMap 的實現。

二、簡介

剛剛咱們也介紹了，在 Map 家族中，WeakHashMap 是一個很特殊的成員，它的特殊之處在於 WeakHashMap 里的元素可能會被 GC 自動刪除，即使程序員沒有显示調用 remove() 或者 clear() 方法。

換言之，當向 WeakHashMap 中添加元素的時候，再次遍歷獲取元素，可能發現它已經不見了，我們來看看下面這個例子。

public static void main(String[] args) {
        Map weakHashMap = new WeakHashMap();
        
        //向weakHashMap中添加4個元素
        for (int i = 0; i < 3; i++) {
            weakHashMap.put("key-"+i, "value-"+ i);
        }
        //輸出添加的元素
        System.out.println("數組長度："+weakHashMap.size() + "，輸出結果：" + weakHashMap);
        
        //主動觸發一次GC
        System.gc();
        
        //再輸出添加的元素
        System.out.println("數組長度："+weakHashMap.size() + "，輸出結果：" + weakHashMap);
    }

輸出結果：

數組長度：3，輸出結果：{key-2=value-2, key-1=value-1, key-0=value-0}
數組長度：3，輸出結果：{}

當主動調用 GC 回收器的時候，再次查詢 WeakHashMap 裏面的數據的時候，內容為空。

更直觀的說，當使用 WeakHashMap 時，即使沒有顯式的添加或刪除任何元素，也可能發生如下情況：

• 調用兩次 size() 方法返回不同的值；
• 兩次調用 isEmpty() 方法，第一次返回 false，第二次返回 true；
• 兩次調用 containsKey() 方法，第一次返回 true，第二次返回 false，儘管兩次使用的是同一個key；
• 兩次調用 get() 方法，第一次返回一個 value，第二次返回 null，儘管兩次使用的是同一個對象。

要明白 WeekHashMap 的工作原理，還需要引入一個概念：弱引用。

我們都知道 Java 中內存是通過 GC 自動管理的，GC 會在程序運行過程中自動判斷哪些對象是可以被回收的，並在合適的時機進行內存釋放。

GC 判斷某個對象是否可被回收的依據是，是否有有效的引用指向該對象。如果沒有有效引用指向該對象（基本意味着不存在訪問該對象的方式），那麼該對象就是可回收的。

2.1、對象引用介紹

從 JDK1.2 版本開始，把對象的引用分為四種級別，從而使程序更加靈活的控制對象的生命周期。這四種級別由高到低依次為：強引用、軟引用、弱引用和虛引用。

用表格整理之後，各個引用類型的區別如下：

2.1.1、強引用

強引用是使用最普遍的引用，例如，我們創建一個對象：

//強引用類型
Object object=new Object();

如果一個對象具有強引用，那垃圾回收器絕不會回收它。當內存空間不足， Java 虛擬機寧願拋出 OutOfMemoryError 錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足的問題。

如果不使用時，要手動通過如下方式來弱化引用，如下：

//將對象設置為null，幫助垃圾收集器回收此對象
object=null;

這個時候，GC 認為該對象不存在引用，就可以回收這個對象，具體什麼時候收集這要取決於 GC 的算法。

2.1.2、軟引用

被SoftReference指向的對象，屬於軟引用，如下：

String str=new String("abc");

//軟引用
SoftReference<String> softRef=new SoftReference<String>(str);

如果一個對象只具有軟引用，則內存空間足夠，垃圾回收器就不會回收它；如果內存空間不足了，就會進入垃圾回收器，Java 虛擬機就會把這個軟引用加入到與之關聯的引用隊列中，GC 進行回收處理。只要垃圾回收器沒有回收它，該對象就可以被程序使用。

當內存不足時，等價於：

If(JVM.內存不足()) {
   str = null;  // 轉換為軟引用
   System.gc(); // 垃圾回收器進行回收
}

軟引用的這種特性，比較適合內存敏感的場景，做高速緩存。在某些場景下，比如，系統內存不是很足的情況下，可以使用軟引用，GC 會自動回收，再次獲取對象的時候，可以對緩存對象進行重建，而又不影響使用。比如：

//創建一個緩存內容cache
String cache = new String("abc");

//進行軟引用處理
SoftReference<String> softRef=new SoftReference<String>(cache);

//判斷是否被垃圾回收器回收
if(softRef.get()!=null){
    //還沒有被回收器回收，直接獲取
    cache = (String) softRef.get();
}else{
    //由於內存吃緊，所以對軟引用的對象回收了
    //重建緩存對象
    cache = new String("abc");
    SoftReference<String> softRef = new SoftReference<String>(cache);
}

2.1.3、弱引用

被WeakReference指向的對象，屬於弱引用，如下：

String str=new String("abc");

//弱引用
WeakReference<String> abcWeakRef = new WeakReference<String>(str);

弱引用與軟引用的區別在於：具有弱引用的對象擁有更短暫的生命周期。

在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由於垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。

當垃圾回收器進行掃描回收時，等價於：

str = null;
System.gc();

如果這個對象是偶爾的使用，並且希望在使用時隨時就能獲取到，但又不想影響此對象的垃圾收集，那麼你應該用 WeakReference 來記住此對象。

同樣的，弱引用對象進入垃圾回收器，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中，GC 進行回收處理。

2.1.4、虛引用

被PhantomReference指向的對象，屬於虛引用。

虛引用與軟引用和弱引用的一個區別在於：虛引用必須和引用隊列聯合使用，如下：

String str=new String("abc");

//創建引用隊列
ReferenceQueue<String> queue = new ReferenceQueue<String>();

//創建虛引用
PhantomReference<String> phantomReference = new PhantomReference<String>(str, queue);

虛引用，顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用並不會決定對象的生命周期。如果一個對象僅持有虛引用，那麼它就和沒有任何引用一樣，在任何時候都可能被垃圾回收器回收。

當垃圾回收器準備回收一個對象時，如果發現它是虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中，GC 進行回收處理。

2.1.5、總結

Java 4中引用的級別由高到低依次為：強引用 > 軟引用 > 弱引用 > 虛引用。

用一張圖來看一下他們之間在垃圾回收時的區別：

再次回到本文要講的 WeakHashMap！

WeakHashMap 內部是通過弱引用來管理 entry 的，弱引用的特性對應到 WeakHashMap 上意味着什麼呢？將一對 key, value 放入到 WeakHashMap 里，隨時都有可能被 GC 回收。

下面，咱們一起來看看 WeakHashMap 的具體實現。

三、常用方法介紹

3.1、put方法

put 方法是將指定的 key, value 對添加到 map 里，存儲結構類似於 HashMap；
不同的是，WeakHashMap 中存儲的 Entry 繼承自 WeakReference，實現了弱引用。

打開源碼如下：

public V put(K key, V value) {
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int i = indexFor(h, tab.length);

        for (Entry<K,V> e = tab[i]; e != null; e = e.next) {
            if (h == e.hash && eq(k, e.get())) {
                V oldValue = e.value;
                if (value != oldValue)
                    e.value = value;
                return oldValue;
            }
        }

        modCount++;
        Entry<K,V> e = tab[i];
        tab[i] = new Entry<>(k, value, queue, h, e);
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
}

WeakHashMap 中存儲的 Entry，源碼如下：

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;

        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
              
            //將key進行弱引用處理
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
        ......
}

需要注意的是，Entry 中super(key, queue)，傳入的是key，因此key才是進行弱引用的，value是直接強引用關聯在this.value中，System.gc()時，對key進行了回收，而value依然保持。

那value是何時被清除的呢？

閱讀源碼，可以看到，調用getTable()函數，對調用expungeStaleEntries()函數，該方法對 jvm 要回收的的 entry(quene 中) 進行遍歷，並將 entry 的 value 設置為空，進行內存回收。

private Entry<K,V>[] getTable() {
        expungeStaleEntries();
        return table;
}

expungeStaleEntries()函數，源碼如下：

private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                    Entry<K,V> e = (Entry<K,V>) x;
                int i = indexFor(e.hash, table.length);

                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                while (p != null) {
                    Entry<K,V> next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;
                        //將value設置為null，方便GC回收
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
}

所以效果是 key 在 GC 的時候被清除，value 在 key 清除后，訪問數組內容的時候進行清除！

3.2、get方法

get 方法根據指定的 key 值返回對應的 value。

源碼如下：

public V get(Object key) {
        Object k = maskNull(key);
        int h = hash(k);
        //訪問數組內容
        Entry<K,V>[] tab = getTable();
        int index = indexFor(h, tab.length);
        Entry<K,V> e = tab[index];
        while (e != null) {
            //通過key，進行hash值和equals判斷
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            e = e.next;
        }
        return null;
}

同樣的，get 方法在判斷對象之前，也調用了getTable()函數，同時，也調用了expungeStaleEntries()函數，所以，可能通過 key 獲取元素的時候，得到空值；如果 key 沒有被 GC 回收，那麼就返回對應的 value。

3.3、remove方法

remove 的作用是通過 key 刪除對應的元素。

源碼如下：

public V remove(Object key) {
        Object k = maskNull(key);
        int h = hash(k);
        
        //訪問數組內容
        Entry<K,V>[] tab = getTable();
        int i = indexFor(h, tab.length);
        Entry<K,V> prev = tab[i];
        Entry<K,V> e = prev;
        
        //循環鏈表，通過key，進行hash值和equals判斷
        while (e != null) {
            Entry<K,V> next = e.next;
            if (h == e.hash && eq(k, e.get())) {
                modCount++;
                size--;
                //找到之後，將鏈表後節點向前移動
                if (prev == e)
                    tab[i] = next;
                else
                    prev.next = next;
                return e.value;
            }
            prev = e;
            e = next;
        }

        return null;
}

同樣的，remove 方法在判斷對象之前，也調用了getTable()函數，同時，也調用了expungeStaleEntries()函數，所以，可能通過 key 獲取元素的時候，可能被垃圾回收器回收，得到空值。

四、總結

WeakHashMap 跟普通的 HashMap 不同，在存儲數據時，key被設置為弱引用類型，而弱引用類型在 java 中，可能隨時被 jvm 的 gc 回收，所以再次通過獲取對象時，可能得到空值，而value是在訪問數組內容的時候，進行清除。

可能很多人覺得這樣做很奇葩，其實不然，WeekHashMap 的這個特點特別適用於需要緩存的場景。

在緩存場景下，由於系統內存是有限的，不能緩存所有對象，可以使用 WeekHashMap 進行緩存對象，即使緩存丟失，也可以通過重新計算得到，不會造成系統錯誤。

五、參考

1、JDK1.7&JDK1.8 源碼

2、

3、

4、

作者：炸雞可樂
出處：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

上一章說了如何製作一個線路圖，當然上一章是手寫的JSON數據，當然手寫的json數據有非常多的好處，例如可以應對客戶的各種BT需求，但是大多數情況下我們都是使用地鐵公司現成的JSON文件,話不多說我們先看一下。

就是這樣的，今天我們就來完成它的大部分需求，以及地鐵公司爸爸提出來的需求。

需求如下：
1.按照不同顏色显示地鐵各線路，显示對應站點。
2.用戶可以點擊手勢縮放和平移（此項目為安卓開發）。
3.用戶在線路menu里點擊線路，對應線路平移值屏幕中心並高亮。
4.根據後台數據，渲染問題路段。
5.點擊問題路段站點，显示問題詳情。

大致需求就是這些，下面看看看代碼

1.定義一些常量和變量

const dataset = subwayData; //線路圖數據源
let subway = new Subway(dataset); //線路圖的類文件
let baseScale = 2; //基礎縮放倍率
let deviceScale = 1400 / 2640; //設備與畫布寬度比率
let width = 2640; //畫布寬
let height = 1760; //畫布高
let transX = 1320 + 260; //地圖X軸平移（將畫布原點X軸平移）
let transY = 580; //地圖X軸平移（將畫布原點Y軸平移）
let scaleExtent = [0.8, 4]; //縮放倍率限制
let currentScale = 2; //當前縮放值
let currentX = 0; //當前畫布X軸平移量
let currentY = 0; //當前畫布Y軸平移量
let selected = false; //線路是否被選中（在右上角的線路菜單被選中）
let scaleStep = 0.5; //點擊縮放按鈕縮放步長默認0.5倍
let tooltip = d3.select('#tooltip'); //提示框
let bugArray = []; //問題路段數組
let svg = d3.select('#sw').append('svg'); //畫布
let group = svg.append('g').attr('transform', `translate(${transX}, ${transY}) scale(1)`);//定義組並平移
let whole = group.append('g').attr('class', 'whole-line') //虛擬線路（用於點擊右上角響應線路可以定位當視野中心，方法不唯一）
let path = group.append('g').attr('class', 'path'); //定義線路
let point = group.append('g').attr('class', 'point'); //定義站點
const zoom = d3.zoom().scaleExtent(scaleExtent).on("zoom", zoomed); //定義縮放事件

這就是我們需要使用的一些常量和變量。注意transX不是寬度的一半，是因為北京地鐵線路網西線更密集。

2.讀官方JSON

使用d3.js數據必不可少，然而官方的數據並不通俗易懂，我們先解讀一下官方JSON數據。

每條線路對象都有一個l_xmlattr屬性和一個p屬性，l_xmlattr是整條線路的屬性，p是站點數組，我們看一下站點中我們需要的屬性。ex是否是中轉站，lb是站名，sid是站的id，rx、ry是文字偏移量，st是是否為站點（因為有的點不是站點而是為了渲染貝塞爾曲線用的），x、y是站點坐標。

3.構造自己的類方法

官方給了我們數據，但是並不是我們能直接使用的，所以我們需要構造自己的方法類

class Subway {
    constructor(data) {
        this.data = data;
        this.bugLineArray = [];
    }
    getInvent() {} //獲取虛擬線路數據
    getPathArray() {} //獲取路徑數據
    getPointArray() {} //獲取站點數組
    getCurrentPathArray() {} //獲取被選中線路的路徑數組
    getCurrentPointArray() {} //獲取被選中線路的站點數組
    getLineNameArray() {} // 獲取線路名稱數組
    getBugLineArray() {} //獲取問題路段數組
}

下面是我們方法內容，裏面的操作不是很優雅（大家將就看啦）

getInvent() {
    let lineArray = [];
    this.data.forEach(d => {
        let { loop, lc, lbx, lby, lb, lid} = d.l_xmlattr;
        let allPoints = d.p.slice(0);
        loop && allPoints.push(allPoints[0]);
        let path = this.formatPath(allPoints, 0, allPoints.length - 1);
        lineArray.push({
            lid: lid,
            path: path,
        })
    })
    return lineArray;
}
getPathArray() {
    let pathArray = [];
    this.data.forEach(d => {
        let { loop, lc, lbx, lby, lb, lid} = d.l_xmlattr;
        let allPoints = d.p.slice(0);
        loop && allPoints.push(allPoints[0])
        let allStations = [];
        allPoints.forEach((item, index) => item.p_xmlattr.st && allStations.push({...item.p_xmlattr, index}))
        let arr = [];
        for(let i = 0; i < allStations.length - 1; i++) {
            let path = this.formatPath(allPoints, allStations[i].index, allStations[i + 1].index);
            arr.push({
                lid: lid,
                id: `${allStations[i].sid}_${allStations[i + 1].sid}`,
                path: path,
                color: lc.replace(/0x/, '#')
            })
        }
        pathArray.push({
            path: arr,
            lc: lc.replace(/0x/, '#'),
            lb,lbx,lby,lid
        })
    })
    return pathArray;
}
getPointArray() {
    let pointArray = [];
    let tempPointsArray = [];
    this.data.forEach(d => {
        let {lid,lc,lb} = d.l_xmlattr;
        let allPoints = d.p;
        let allStations = [];
        allPoints.forEach(item => {
            if(item.p_xmlattr.st && !item.p_xmlattr.ex) {
                allStations.push({...item.p_xmlattr, lid, pn: lb, lc: lc.replace(/0x/, '#')})
            } else if (item.p_xmlattr.ex) {
                if(tempPointsArray.indexOf(item.p_xmlattr.sid) == -1) {
                    allStations.push({...item.p_xmlattr, lid, pn: lb, lc: lc.replace(/0x/, '#')})
                    tempPointsArray.push(item.p_xmlattr.sid);
                }
            }
        });
        pointArray.push(allStations);
    })
    return pointArray;
}
getCurrentPathArray(name) {
    let d = this.data.filter(d => d.l_xmlattr.lid == name)[0];
    let { loop, lc, lbx, lby, lb, lid} = d.l_xmlattr;
    let allPoints = d.p.slice(0);
    loop && allPoints.push(allPoints[0])
    let allStations = [];
    allPoints.forEach((item, index) => item.p_xmlattr.st && allStations.push({...item.p_xmlattr, index}))
    let arr = [];
    for(let i = 0; i < allStations.length - 1; i++) {
        let path = this.formatPath(allPoints, allStations[i].index, allStations[i + 1].index);
        arr.push({
            lid: lid,
            id: `${allStations[i].sid}_${allStations[i + 1].sid}`,
            path: path,
            color: lc.replace(/0x/, '#')
        })
    }
    return {
        path: arr,
        lc: lc.replace(/0x/, '#'),
        lb,lbx,lby,lid
    }
}
getCurrentPointArray(name) {
    let d = this.data.filter(d => d.l_xmlattr.lid == name)[0];
    let {lid,lc,lb} = d.l_xmlattr;
    let allPoints = d.p;
    let allStations = [];
    allPoints.forEach(item => {
        if(item.p_xmlattr.st && !item.p_xmlattr.ex) {
            allStations.push({...item.p_xmlattr, lid, pn: lb, lc: lc.replace(/0x/, '#')})
        } else if (item.p_xmlattr.ex) {
            allStations.push({...item.p_xmlattr, lid, pn: lb, lc: lc.replace(/0x/, '#')})
        }
    });
    return allStations;
}
getLineNameArray() {
    let nameArray = this.data.map(d => {
        return {
            lb: d.l_xmlattr.lb,
            lid: d.l_xmlattr.lid,
            lc: d.l_xmlattr.lc.replace(/0x/, '#')
        }
    })
    return nameArray;
}
getBugLineArray(arr) {
    if(!arr || !arr.length) return [];
    this.bugLineArray = [];
    arr.forEach(item => {
        let { start, end, cause, duration, lid, lb } = item;
        let lines = [];
        let points = [];
        let tempObj = this.data.filter(d => d.l_xmlattr.lid == lid)[0];
        let loop = tempObj.l_xmlattr.loop;
        let lc = tempObj.l_xmlattr.lc;
        let allPoints = tempObj.p;
        let allStations = [];
        allPoints.forEach(item => {
            if(item.p_xmlattr.st) {
                allStations.push(item.p_xmlattr.sid)
            }
        });
        loop && allStations.push(allStations[0]);
        for(let i=allStations.indexOf(start); i<=allStations.lastIndexOf(end); i++) {
            points.push(allStations[i])
        }
        for(let i=allStations.indexOf(start); i<allStations.lastIndexOf(end); i++) {
            lines.push(`${allStations[i]}_${allStations[i+1]}`)
        }
        this.bugLineArray.push({cause,duration,lid,lb,lines,points,lc: lc.replace(/0x/, '#'),start: points[0],end:points[points.length - 1]});
    })
    return this.bugLineArray;

這種方法大家也不必看懂，知道傳入了什麼，輸入了什麼即可，這就是我們的方法類。

4.d3渲染畫布並添加方法

這裡是js的核心代碼，既然class文件都寫完了，這裏的操作就方便了很多，主要就是下面幾個人方法，

renderInventLine(); //渲染虛擬新路
renderAllStation(); //渲染所有的線路名稱（右上角）
renderBugLine(); //渲染問題路段
renderAllLine(); //渲染所有線路
renderAllPoint(); //渲染所有點
renderCurrentLine() //渲染當前選中的線路
renderCurrentPoint() //渲染當前選中的站點
zoomed() //縮放時執行的方法
getCenter() //獲取虛擬線中心點的坐標
scale() //點擊縮放按鈕時執行的方法

下面是對應的方法體

svg.call(zoom);
svg.call(zoom.transform, d3.zoomIdentity.translate((1 - baseScale) * transX, (1 - baseScale) * transY).scale(baseScale));

let pathArray = subway.getPathArray();
let pointArray = subway.getPointArray();

renderInventLine();
renderAllStation();
renderBugLine();

function renderInventLine() {
    let arr = subway.getInvent();
    whole.selectAll('path')
    .data(arr)
    .enter()
    .append('path')
    .attr('d', d => d.path)
    .attr('class', d => d.lid)
    .attr('stroke', 'none')
    .attr('fill', 'none')
}

function renderAllLine() {
    for (let i = 0; i < pathArray.length; i++) {
        path.append('g')
        .selectAll('path')
        .data(pathArray[i].path)
        .enter()
        .append('path')
        .attr('d', d => d.path)
        .attr('lid', d => d.lid)
        .attr('id', d => d.id)
        .attr('class', 'lines origin')
        .attr('stroke', d => d.color)
        .attr('stroke-width', 7)
        .attr('stroke-linecap', 'round')
        .attr('fill', 'none')
        path.append('text')
        .attr('x', pathArray[i].lbx)
        .attr('y', pathArray[i].lby)
        .attr('dy', '1em')
        .attr('dx', '-0.3em')
        .attr('fill', pathArray[i].lc)
        .attr('lid', pathArray[i].lid)
        .attr('class', 'line-text origin')
        .attr('font-size', 14)
        .attr('font-weight', 'bold')
        .text(pathArray[i].lb)
    }
}

function renderAllPoint() {
    for (let i = 0; i < pointArray.length; i++) {
        for (let j = 0; j < pointArray[i].length; j++) {
            let item = pointArray[i][j];
            let box = point.append('g');
            if (item.ex) {
                box.append('image')
                .attr('href', './trans.png')
                .attr('class', 'points origin')
                .attr('id', item.sid)
                .attr('x', item.x - 8)
                .attr('y', item.y - 8)
                .attr('width', 16)
                .attr('height', 16)
            } else {
                box.append('circle')
                .attr('cx', item.x)
                .attr('cy', item.y)
                .attr('r', 5)
                .attr('class', 'points origin')
                .attr('id', item.sid)
                .attr('stroke', item.lc)
                .attr('stroke-width', 1.5)
                .attr('fill', '#ffffff')
            }
            box.append('text')
            .attr('x', item.x + item.rx)
            .attr('y', item.y + item.ry)
            .attr('dx', '0.3em')
            .attr('dy', '1.1em')
            .attr('font-size', 11)
            .attr('class', 'point-text origin')
            .attr('lid', item.lid)
            .attr('id', item.sid)
            .text(item.lb)
        }
    }
}

function renderCurrentLine(name) {
    let arr = subway.getCurrentPathArray(name);
    path.append('g')
    .attr('class', 'temp')
    .selectAll('path')
    .data(arr.path)
    .enter()
    .append('path')
    .attr('d', d => d.path)
    .attr('lid', d => d.lid)
    .attr('id', d => d.id)
    .attr('stroke', d => d.color)
    .attr('stroke-width', 7)
    .attr('stroke-linecap', 'round')
    .attr('fill', 'none')
    path.append('text')
    .attr('class', 'temp')
    .attr('x', arr.lbx)
    .attr('y', arr.lby)
    .attr('dy', '1em')
    .attr('dx', '-0.3em')
    .attr('fill', arr.lc)
    .attr('lid', arr.lid)
    .attr('font-size', 14)
    .attr('font-weight', 'bold')
    .text(arr.lb)
}

function renderCurrentPoint(name) {
    let arr = subway.getCurrentPointArray(name);
    for (let i = 0; i < arr.length; i++) {
        let item = arr[i];
        let box = point.append('g').attr('class', 'temp');
        if (item.ex) {
            box.append('image')
            .attr('href', './trans.png')
            .attr('x', item.x - 8)
            .attr('y', item.y - 8)
            .attr('width', 16)
            .attr('height', 16)
            .attr('id', item.sid)
        } else {
            box.append('circle')
            .attr('cx', item.x)
            .attr('cy', item.y)
            .attr('r', 5)
            .attr('id', item.sid)
            .attr('stroke', item.lc)
            .attr('stroke-width', 1.5)
            .attr('fill', '#ffffff')
        }
        box.append('text')
        .attr('class', 'temp')
        .attr('x', item.x + item.rx)
        .attr('y', item.y + item.ry)
        .attr('dx', '0.3em')
        .attr('dy', '1.1em')
        .attr('font-size', 11)
        .attr('lid', item.lid)
        .attr('id', item.sid)
        .text(item.lb)
    }
}

function renderBugLine(modal) {
    let bugLineArray = subway.getBugLineArray(modal);
    d3.selectAll('.origin').remove();
    renderAllLine();
    renderAllPoint();
    bugLineArray.forEach(d => {
        console.log(d)
        d.lines.forEach(dd => {
            d3.selectAll(`path#${dd}`).attr('stroke', '#eee');
        })
        d.points.forEach(dd => {
            d3.selectAll(`circle#${dd}`).attr('stroke', '#ddd')
            d3.selectAll(`text#${dd}`).attr('fill', '#aaa')
        })
    })
    d3.selectAll('.points').on('click', function () {
        let id = d3.select(this).attr('id');
        let bool = judgeBugPoint(bugLineArray, id);
        if (bool) {
            let x, y;
            if (d3.select(this).attr('href')) {
                x = parseFloat(d3.select(this).attr('x')) + 8;
                y = parseFloat(d3.select(this).attr('y')) + 8;
            } else {
                x = d3.select(this).attr('cx');
                y = d3.select(this).attr('cy');
            }
            let toolX = (x * currentScale + transX - ((1 - currentScale) * transX - currentX)) * deviceScale;
            let toolY = (y * currentScale + transY - ((1 - currentScale) * transY - currentY)) * deviceScale;
            let toolH = document.getElementById('tooltip').offsetHeight;
            let toolW = 110;
            if (toolY < 935 / 2) {
                tooltip.style('left', `${toolX - toolW}px`).style('top', `${toolY + 5}px`);
            } else {
                tooltip.style('left', `${toolX - toolW}px`).style('top', `${toolY - toolH - 5}px`);
            }
        }
    });
}

function judgeBugPoint(arr, id) {
    if (!arr || !arr.length || !id) return false;
    let bugLine = arr.filter(d => {
        return d.points.indexOf(id) > -1
    });
    if (bugLine.length) {
        removeTooltip()
        tooltip.select('#tool-head').html(`<span>${id}</span><div class="deletes" onclick="removeTooltip()">×</div>`);
        bugLine.forEach(d => {
            let item = tooltip.select('#tool-body').append('div').attr('class', 'tool-item');
            item.html(`
                <div class="tool-content">
                    <div style="color: #ffffff;border-bottom: 2px solid ${d.lc};">
                        <span style="background: ${d.lc};padding: 4px 6px;">${d.lb}</span>
                    </div>
                    <div>
                        <div class="content-left">封路時間</div><div class="content-right">${d.duration}</div>
                    </div>
                    <div>
                        <div class="content-left">封路原因</div><div class="content-right">${d.cause}</div>
                    </div>
                    <div>
                        <div class="content-left">封路路段</div><div class="content-right">${d.start}-${d.end}</div>
                    </div>
                </div>
            `)
        })
        d3.select('#tooltip').style('display', 'block');
        return true;
    } else {
        return false;
    }
}

function removeTooltip() {
    d3.selectAll('.tool-item').remove();
    d3.select('#tooltip').style('display', 'none');
}

function zoomed() {
    removeTooltip();
    let {x, y, k} = d3.event.transform;
    currentScale = k;
    currentX = x;
    currentY = y;
    group.transition().duration(50).ease(d3.easeLinear).attr("transform", () => `translate(${x + transX * k}, ${y + transY * k}) scale(${k})`)
}

function getCenter(str) {
    if (!str) return null;
    let x, y;
    let tempArr = [];
    let tempX = [];
    let tempY = [];
    str.split(' ').forEach(d => {
        if (!isNaN(d)) {
            tempArr.push(d)
        }
    })

    tempArr.forEach((d, i) => {
        if (i % 2 == 0) {
            tempX.push(parseFloat(d))
        } else {
            tempY.push(parseFloat(d))
        }
    })
    x = (d3.min(tempX) + d3.max(tempX)) / 2;
    y = (d3.min(tempY) + d3.max(tempY)) / 2;
    return [x, y]
}

function renderAllStation() {
    let nameArray = subway.getLineNameArray();
    let len = Math.ceil(nameArray.length / 5);
    let box = d3.select('#menu').append('div')
    .attr('class', 'name-box')
    for (let i = 0; i < len; i++) {
        let subwayCol = box.append('div')
        .attr('class', 'subway-col')
        let item = subwayCol.selectAll('div')
        .data(nameArray.slice(i * 5, (i + 1) * 5))
        .enter()
        .append('div')
        .attr('id', d => d.lid)
        .attr('class', 'name-item')
        item.each(function (d) {
            d3.select(this).append('span').attr('class', 'p_mark').style('background', d.lc);
            d3.select(this).append('span').attr('class', 'p_name').text(d.lb);
            d3.select(this).on('click', d => {
                selected = true;
                d3.selectAll('.origin').style('opacity', 0.1);
                d3.selectAll('.temp').remove();
                renderCurrentLine(d.lid);
                renderCurrentPoint(d.lid);
                let arr = getCenter(d3.select(`path.${d.lid}`).attr('d'));
                svg.call(zoom.transform, d3.zoomIdentity.translate((width / 2 - transX) - arr[0] - (arr[0] + transX) * (currentScale - 1), (height / 2 - transY) - arr[1] - (arr[1] + transY) * (currentScale - 1)).scale(currentScale));
            })
        })
    }
}

function scale(type) {
    if (type && currentScale + scaleStep <= scaleExtent[1]) {
        svg.call(zoom.transform, d3.zoomIdentity.translate((1 - currentScale - scaleStep) * transX - ((1 - currentScale) * transX - currentX) * (currentScale + scaleStep) / currentScale, (1 - currentScale - scaleStep) * transY - ((1 - currentScale) * transY - currentY) * (currentScale + scaleStep) / currentScale).scale(currentScale + scaleStep));
    } else if (!type && currentScale - scaleStep >= scaleExtent[0]) {
        svg.call(zoom.transform, d3.zoomIdentity.translate((1 - (currentScale - scaleStep)) * transX - ((1 - currentScale) * transX - currentX) * (currentScale - scaleStep) / currentScale, (1 - (currentScale - scaleStep)) * transY - ((1 - currentScale) * transY - currentY) * (currentScale - scaleStep) / currentScale).scale(currentScale - scaleStep));
    }
}

上面是大部分代碼，想看全部的可以查看demo。

原文鏈接

大家轉載請註明一下原文 謝謝大家

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※公開收購3c價格,不怕被賤賣!

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

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

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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