proxy源碼

⑴ java代理的作用和實現

JDK 動態代理

動態代理的核心其實就是代理對象的生成，即 Proxy.newProxyInstance(classLoader, proxyInterface, handler)。

讓我們進入newProxyInstance方法觀摩下，核心代碼其實就三行。

這個方法需要三個參數：

• ClassLoader，用於載入代理類的 Loader 類，通常這個 Loader 和被代理的類是同一個 Loader 類。

• Interfaces，是要被代理的那些那些介面。

• InvocationHandler，就是用於執行除了被代理介面中方法之外的用戶自定義的操作，也是用戶需要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。

• //獲取代理類 Class cl = getProxyClass(loader, interfaces);


• //獲取帶有InvocationHandler參數的構造方法 Constructor cons = cl.getConstructor(constructorParams);


• //把handler傳入構造方法生成實例 return (Object) cons.newInstance(new Object[] { h });



一個典型的動態代理創建對象過程可分為以下四個步驟：

1、通過實現InvocationHandler介面創建調用處理器

• IvocationHandler handler = new InvocationHandlerImpl(...);



2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類

• Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});



3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型

• Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});



4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入

• Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));



為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。

• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new InvocationHandlerImpl (real));



生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。

創建代理對象時序圖



獲取代理類

getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：

在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。

• // 緩存的key使用介面名稱生成的List Object key = Arrays.asList(interfaceNames);


• synchronized (cache) {


• do {


• Object value = cache.get(key);


• // 緩存里保存了代理類的引用 if (value instanceof Reference) {


• proxyClass = (Class) ((Reference) value).get();


• }


• if (proxyClass != null) {


• // 代理類已經存在則返回


• return proxyClass;


• } else if (value == pendingGenerationMarker) {


• // 如果代理類正在產生，則等待


• try {


• cache.wait();


• } catch (InterruptedException e) {


• }


• continue;


• } else {


• //沒有代理類，則標記代理准備生成


• cache.put(key, pendingGenerationMarker);


• break;


• }


• } while (true);


• }



生成並載入代理類

代理類的生成主要是以下這兩行代碼：

• //生成代理類的位元組碼文件並保存到硬碟中(默認不保存到硬碟) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);


• //使用類載入器將位元組碼載入到內存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);



代理類的生成過程


ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
JD-GUI這樣的反編譯軟體打開jrelib t.jar來一探究竟，以下是其核心代碼的分析。

• //添加介面中定義的方法，此時方法體為空 for (int i = 0; i < this.interfaces.length; i++) {


• localObject1 = this.interfaces[i].getMethods();


• for (int k = 0; k < localObject1.length; k++) {


• addProxyMethod(localObject1[k], this.interfaces[i]);


• }


• }


• //添加一個帶有InvocationHandler的構造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);


• //循環生成方法體代碼（省略） //方法體里生成調用InvocationHandler的invoke方法代碼。（此處有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;")


• //將生成的位元組碼，寫入硬碟，前面有個if判斷，默認情況下不保存到硬碟。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class");


• localFileOutputStream.write(this.val$classFile);



生成的代理類源碼

那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。

• public class ProxyBusiness extends Proxy implements IBusiness, IBusiness2 {


• private LogInvocationHandler h;


• @Override public void doSomeThing2() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing2",null);


• h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• }


• @Override public boolean doSomeThing() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing", null);


• return (Boolean) h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• return false;


• }


• public ProxyBusiness(LogInvocationHandler h) {


• this.h = h;


• }



測試代理的代碼如下：

• //測試public static void main(String[] args) {


• //構建AOP的Advice


• LogInvocationHandler handler = new LogInvocationHandler(new Business());


• new ProxyBusiness(handler).doSomeThing();


• new ProxyBusiness(handler).doSomeThing2();


• }



下面看一個自定義代理的實現。

被代理類介面

• public interface Subject {


• public void doSomething();


• }



被代理類

• //目標對象public class RealSubject implements Subject{ public void doSomething() {


• System.out.println( "call doSomething()" );


• }


• }



調用處理器(切面)

• public class ProxyHandler implements InvocationHandler {


• private Object proxied;


• public ProxyHandler( Object proxied ) {


• this.proxied = proxied;


• }


• public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable {


• //在轉調具體目標對象之前，可以執行一些功能處理System.out.println( "doSomething before" ); //轉調具體目標對象的方法


• return method.invoke( proxied, args);


• //在轉調具體目標對象之後，可以執行一些功能處理System.out.println( "doSomething after" );


• }


• }



測試我們的代理實現

• public class DynamicProxy {


• public static void main( String args[] ) {


• RealSubject real = new RealSubject();


• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new ProxyHandler(real));


• proxySubject.doSomething(); //write proxySubject class binary data to file


• createProxyClassFile();


• }


• public static void createProxyClassFile() {


• String name = "ProxySubject";


• byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );


• try{


• FileOutputStream out = new FileOutputStream( name + ".class" );


• out.write( data );


• out.close();


• }catch( Exception e ) {


• e.printStackTrace();


• }


• }


• }



運行結果：

• doSomething beforecall doSomething()doSomething after



Proxy 介面

Proxy 的主要靜態變數

• // 映射表：用於維護類裝載器對象到其對應的代理類緩存private static Map loaderToCache = new WeakHashMap();// 標記：用於標記一個動態代理類正在被創建中private static Object pendingGenerationMarker = new Object();// 同步表：記錄已經被創建的動態代理類類型，主要被方法 isProxyClass 進行相關的判斷private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());// 關聯的調用處理器引用protected InvocationHandler h;


• Proxy的構造方法// 由於 Proxy 內部從不直接調用構造函數，所以 private 類型意味著禁止任何調用private Proxy() {}// 由於 Proxy 內部從不直接調用構造函數，所以 protected 意味著只有子類可以調用protected Proxy(InvocationHandler h) {this.h = h;}



ProxySubject 源碼

創建的代理類 ProxySubject.class

• import java.lang.reflect.*;


• public final class ProxySubject extends Proxy implements Subject{


• private static Method m1;


• private static Method m0;


• private static Method m3;


• private static Method m2;


• public ProxySubject(InvocationHandler invocationhandler){


• super(invocationhandler);


• }


• public final boolean equals(Object obj){


• try {


• return ((Boolean)super.h.invoke(this, m1, new Object[] {


• obj


• })).booleanValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final int hashCode() {


• try {


• return ((Integer)super.h.invoke(this, m0, null)).intValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• /*關鍵部分*/


• public final void doSomething() {


• try {


• // Proxy類中protected InvocationHandler h;關聯的調用處理器引用


• super.h.invoke(this, m3, null);


• return;


• }catch(Error _ex) {


• }catch(Throwable throwable) {


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final String toString() {


• try {


• return (String)super.h.invoke(this, m2, null);


• } catch(Error _ex) {


• } catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• static{


• try {


• m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {


• Class.forName("java.lang.Object")


• });


• m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);


• m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);


• m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);


• }catch(NoSuchMethodException nosuchmethodexception) {


• throw new NoSuchMethodError(nosuchmethodexception.getMessage());


• }catch(ClassNotFoundException classnotfoundexception){


• throw new NoClassDefFoundError(classnotfoundexception.getMessage());


• }


• }


• }



CGLib 動態代理

動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。

• public static void main(String[] args) {


• byteCodeGe();


• }


• public static void byteCodeGe() {


• //創建一個織入器


• Enhancer enhancer = new Enhancer();


• //設置父類


• enhancer.setSuperclass(Business.class);


• //設置需要織入的邏輯


• enhancer.setCallback(new LogIntercept());


• //使用織入器創建子類


• IBusiness2 newBusiness = (IBusiness2) enhancer.create();


• newBusiness.doSomeThing2();


• }


• /**


• * 記錄日誌


• */ public static class LogIntercept implements MethodInterceptor {


• @Override


• public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {


• //執行原有邏輯，注意這里是invokeSuper


• Object rev = proxy.invokeSuper(target, args);


• //執行織入的日誌


• if (method.getName().equals("doSomeThing2")) {


• System.out.println("記錄日誌");


• }


• return rev;


• }


• }

⑵ java 動態代理 生成的$Proxy0 用什麼方式可以獲取$Proxy0類的源碼

byte[] proxyClass = ProxyGenerator.generateProxyClass(proxy.getClass().getSimpleName(),proxy.getClass().getInterfaces());

然後將byte數組的數據通過文件流寫入文件即可。注意proxy是代理對象

⑶ OkHttp源碼解析 （三）——代理和路由

初看OkHttp源碼，由於對Address、Route、Proxy、ProxySelector、RouteSelector等理解不夠，讀源碼非常吃力，看了幾遍依然對於尋找復用連接、創建連接、連接伺服器、連接代理伺服器、創建隧道連接等邏輯似懂非懂，本篇決定梳理一遍相關的概念及基本原理。

● HTTP/1.1(HTTPS)
● HTTP/2
● SPDY

一個http請求的流程（直連）：
1、輸入url及參數；
2、如果是url是域名則解析ip地址，可能對應多個ip，如果沒有指定埠，則用默認埠，http請求用80；
3、創建socket，根據ip和埠連接伺服器（socket內部會完成3次TCP握手）；
4、socket成功連接後，發送http報文數據。

一個https請求的流程（直連）：
1、輸入url及參數；
2、如果是url是域名則解析ip地址，可能對應多個ip，如果沒有指定埠，則用默認埠，https請求用443；
3、創建socket，根據ip和埠連接伺服器（socket內部會完成3次TCP握手）；
4、socket成功連接後進行TLS握手，可通過java標准款提供的SSLSocket完成；
5、握手成功後，發送https報文數據。

1、分類
● HTTP代理：普通代理、隧道代理
● SOCKS代理：SOCKS4、SOCKS5

2、HTTP代理分類及說明
普通代理
HTTP/1.1 協議的第一部分。其代理過程為：
● client 請求 proxy
● proxy 解析請求獲取 origin server 地址
● proxy 向 origin server 轉發請求
● proxy 接收 origin server 的響應
● proxy 向 client 轉發響應
其中proxy獲取目的伺服器地址的標准方法是解析 request line 里的 request-URL。因為proxy需要解析報文，因此普通代理無法適用於https，因為報文都是加密的。

隧道代理
通過 Web 代理伺服器用隧道方式傳輸基於 TCP 的協議。
請求包括兩個階段，一是連接（隧道）建立階段，二是數據通信（請求響應）階段，數據通信是基於 TCP packet ，代理伺服器不會對請求及響應的報文作任何的處理，都是原封不動的轉發，因此可以代理 HTTPS請求和響應。
代理過程為：
● client 向 proxy 發送 CONNET 請求（包含了 origin server 的地址）
● proxy 與 origin server 建立 TCP 連接
● proxy 向 client 發送響應
● client 向 proxy 發送請求，proxy 原封不動向 origin server 轉發請求，請求數據不做任何封裝，為原生 TCP packet.

3、SOCKS代理分類及說明
● SOCKS4：只支持TCP協議（即傳輸控制協議）
● SOCKS5: 既支持TCP協議又支持UDP協議（即用戶數據包協議），還支持各種身份驗證機制、伺服器端域名解析等。
SOCK4能做到的SOCKS5都可得到，但反過來卻不行，比如我們常用的聊天工具QQ在使用代理時就要求用SOCKS5代理，因為它需要使用UDP協議來傳輸數據。

有了上面的基礎知識，下面分析結合源碼分析OkHttp路由相關的邏輯。OkHttp用Address來描述與目標伺服器建立連接的配置信息，但請求輸入的可能是域名，一個域名可能對於多個ip，真正建立連接是其中一個ip，另外，如果設置了代理，客戶端是與代理伺服器建立直接連接，而不是目標伺服器，代理又可能是域名，可能對應多個ip。因此，這里用Route來描述最終選擇的路由，即客戶端與哪個ip建立連接，是代理還是直連。下面對比下Address及Route的屬性，及路由選擇器RouteSelector。

描述與目標伺服器建立連接所需要的配置信息，包括目標主機名、埠、dns，SocketFactory，如果是https請求，包括TLS相關的SSLSocketFactory 、HostnameVerifier 、CertificatePinner，代理伺服器信息Proxy 、ProxySelector 。

Route提供了真正連接伺服器所需要的動態信息，明確需要連接的伺服器IP地址及代理伺服器，一個Address可能會有很多個路由Route供選擇（一個DNS對應對個IP）。

Address和Route都是數據對象，沒有提供操作方法，OkHttp另外定義了RouteSelector來完成選擇的路由的操作。

1、讀取代理配置信息：resetNextProxy()

讀取代理配置：
● 如果有指定代理（不讀取系統配置，在OkHttpClient實例中指定），則只用1個該指定代理；
● 如果沒有指定，則讀取系統配置的，可能有多個。

2、獲取需要嘗試的socket地址（目標伺服器或者代理伺服器）：resetNextInetSocketAddress()

結合Address的host和代理，解析要嘗試的套接字地址（ip+埠）列表：
● 直連或者SOCK代理， 則用目標伺服器的主機名和埠，如果是HTTP代理，則用代理伺服器的主機名和埠；
● 如果是SOCK代理，根據目標伺服器主機名和埠號創建未解析的套接字地址，列表只有1個地址；
● 如果是直連或HTTP代理，先DNS解析，得到InetAddress列表（沒有埠），再創建InetSocketAddress列表（帶上埠），InetSocketAddress與InetAddress的區別是前者帶埠信息。

3、獲取路由列表：next()

選擇路由的流程解析：
● 遍歷每個代理對象，可能多個，直連的代理對象為Proxy.DIRECT（實際是沒有中間代理的）；
● 對每個代理獲取套接字地址列表；
● 遍歷地址列表，創建Route，判斷Route如果在路由黑名單中，則添加到失敗路由列表，不在黑名單中則添加到待返回的Route列表；
● 如果最後待返回的Route列表為空，即可能所有路由都在黑名單中，實在沒有新路由了，則將失敗的路由集合返回；
● 傳入Route列表創建Selection對象，對象比較簡單，就是一個目標路由集合，及讀取方法。

為了避免不必要的嘗試，OkHttp會把連接失敗的路由加入到黑名單中，由RouteDatabase管理，該類比較簡單，就是一個失敗路由集合。

1、創建Address
Address的創建在RetryAndFollowUpInteceptor里，每次請求會聲明一個新的Address及StreamAllocation對象，而StreamAllocation使用Address創建RouteSelector對象，在連接時RouteSelector確定請求的路由。

每個Requst都會構造一個Address對象，構造好了Address對象只是有了與伺服器連接的配置信息，但沒有確定最終伺服器的ip，也沒有確定連接的路由。

2、創建RouteSelector
在StreamAllocation聲明的同時會聲明路由選擇器RouteSelector，為一次請求尋找路由。

3、選擇可用的路由Route

下面在測試過程跟蹤實例對象來理解，分別測試直連和HTTP代理HTTP2請求路由的選擇過程：
● 直連請求流程
● HTTP代理HTTPS流程
請求url： https://www.jianshu.com/p/63ba15d8877a

1、構造address對象

2、讀取代理配置：resetNextProxy

3、解析目標伺服器套接字地址：resetNextInetSocketAddress

4、選擇Route創建RealConnection

5、確定協議

測試方法：
● 在PC端打開Charles，設置埠，如何設置代理，網上有教程，比較簡單；
● 手機打開WIFI，選擇連接的WIFI修改網路，在高級選項中設置中指定了代理伺服器，ip為PC的ip，埠是Charles剛設置的埠；
● OkHttpClient不指定代理，發起請求。

1、構造address對象

2、讀取代理配置：resetNextProxy

3、解析目標伺服器套接字地址：resetNextInetSocketAddress

4、選擇Route創建RealConnection

5、創建隧道
由於是代理https請求，需要用到隧道代理。

從圖可以看出，建立隧道其實是發送CONNECT請求，header包括欄位Proxy-Connection，目標主機名，請求內容類似：

6、確定協議，SSL握手

1、代理可分為HTTP代理和SOCK代理；
2、HTTP代理又分為普通代理和隧道代理；普通代理適合明文傳輸，即http請求；隧道代理僅轉發TCP包，適合加密傳輸，即https/http2;
3、SOCK代理又分為SOCK4和SOCK5，區別是後者支持UDP傳輸，適合代理聊天工具如QQ；
4、沒有設置代理（OkHttpClient沒有指定同時系統也沒有設置），客戶端直接與目標伺服器建立TCP連接；
5、設置了代理，代理http請求時，客戶端與代理伺服器建立TCP連接，如果代理伺服器是域名，則解釋代理伺服器域名，而目標伺服器的域名由代理伺服器解析；
6、設置了代理，代理https/http2請求時，客戶端與代理伺服器建立TCP連接，發送CONNECT請求與代理伺服器建立隧道，並進行SSL握手，代理伺服器不解析數據，僅轉發TCP數據包。

如何正確使用 HTTP proxy
OkHttp3中的代理與路由
HTTP 代理原理及實現（一）

⑷ 深入理解 HttpSecurity【源碼篇】

HttpSecurity 也是 Spring Security 中的重要一環。我們平時所做的大部分 Spring Security 配置也都是基於 HttpSecurity 來配置的。因此我們有必要從源碼的角度來理解下 HttpSecurity 到底幹了啥？

首先我們來看下 HttpSecurity 的繼承關系圖：

可以看到，HttpSecurity 繼承自 ，同時實現了 SecurityBuilder 和 HttpSecurityBuilder 兩個介面。

我們來看下 HttpSecurity 的定義：

這里每一個類都帶有泛型，看得人有點眼花繚亂。

我把這個泛型類拿出來和大家講一下，小夥伴們就明白了。

泛型主要是兩個，DefaultSecurityFilterChain 和 HttpSecurity，HttpSecurity 就不用說了，這是我們今天的主角，那麼 DefaultSecurityFilterChain 是幹嘛的？

這我們就得從 SecurityFilterChain 說起了。

先來看定義：

SecurityFilterChain 其實就是我們平時所說的 Spring Security 中的過濾器鏈，它里邊定義了兩個方法，一個是 matches 方法用來匹配請求，另外一個 getFilters 方法返回一個 List 集合，集合中放著 Filter 對象，當一個請求到來時，用 matches 方法去比較請求是否和當前鏈吻合，如果吻合，就返回 getFilters 方法中的過濾器，那麼當前請求會逐個經過 List 集合中的過濾器。這一點，小夥伴們可以回憶前面【深入理解 FilterChainProxy【源碼篇】】一文。

SecurityFilterChain 介面只有一個實現類，那就是 DefaultSecurityFilterChain：

DefaultSecurityFilterChain 只是對 SecurityFilterChain 中的方法進行了實現，並沒有特別值得說的地方，松哥也就不啰嗦了。

那麼從上面的介紹中，大家可以看到，DefaultSecurityFilterChain 其實就相當於是 Spring Security 中的過濾器鏈，一個 DefaultSecurityFilterChain 代表一個過濾器鏈，如果系統中存在多個過濾器鏈，則會存在多個 DefaultSecurityFilterChain 對象。

接下來我們把 HttpSecurity 的這幾個父類捋一捋。

SecurityBuilder 就是用來構建過濾器鏈的，在 HttpSecurity 實現 SecurityBuilder 時，傳入的泛型就是 DefaultSecurityFilterChain，所以 SecurityBuilder#build 方法的功能很明確，就是用來構建一個過濾器鏈出來。

HttpSecurityBuilder 看名字就是用來構建 HttpSecurity 的。不過它也只是一個介面，具體的實現在 HttpSecurity 中，介面定義如下：

這里的方法比較簡單：

這便是 HttpSecurityBuilder 中的功能，這些介面在 HttpSecurity 中都將得到實現。

AbstractSecurityBuilder 類實現了 SecurityBuilder 介面，該類中主要做了一件事，就是確保整個構建只被構建一次。

可以看到，這里重新定義了 build 方法，並設置 build 方法為 final 類型，無法被重寫，在 build 方法中，通過 AtomicBoolean 實現該方法只被調用一次。具體的構建邏輯則定義了新的抽象方法 doBuild，將來在實現類中通過 doBuild 方法定義構建邏輯。

AbstractSecurityBuilder 方法的實現類就是 。

中所做的事情就比較多了，我們分別來看。

首先 中定義了一個枚舉類，將整個構建過程分為 5 種狀態，也可以理解為構建過程生命周期的五個階段，如下：

五種狀態分別是 UNBUILT、INITIALIZING、CONFIGURING、BUILDING 以及 BUILT。另外還提供了兩個判斷方法，isInitializing 判斷是否正在初始化，isConfigured 表示是否已經配置完畢。

中的方法比較多，松哥在這里列出來兩個關鍵的方法和大家分析：

第一個就是這個 add 方法，這相當於是在收集所有的配置類。將所有的 xxxConfigure 收集起來存儲到 configurers 中，將來再統一初始化並配置，configurers 本身是一個 LinkedHashMap ，key 是配置類的 class，value 是一個集合，集合里邊放著 xxxConfigure 配置類。當需要對這些配置類進行集中配置的時候，會通過 getConfigurers 方法獲取配置類，這個獲取過程就是把 LinkedHashMap 中的 value 拿出來，放到一個集合中返回。

另一個方法就是 doBuild 方法。

在 AbstractSecurityBuilder 類中，過濾器的構建被轉移到 doBuild 方法上面了，不過在 AbstractSecurityBuilder 中只是定義了抽象的 doBuild 方法，具體的實現在 。

doBuild 方法就是一邊更新狀態，進行進行初始化。

beforeInit 是一個預留方法，沒有任何實現。

init 方法就是找到所有的 xxxConfigure，挨個調用其 init 方法進行初始化。

beforeConfigure 是一個預留方法，沒有任何實現。

configure 方法就是找到所有的 xxxConfigure，挨個調用其 configure 方法進行配置。

最後則是 performBuild 方法，是真正的過濾器鏈構建方法，但是在 中 performBuild 方法只是一個抽象方法，具體的實現在 HttpSecurity 中。

這便是 HttpSecurity 所有父類、父介面的功能。

看完了父輩，接下來回到我們今天文章的主題，HttpSecurity。

HttpSecurity 做的事情，就是進行各種各樣的 xxxConfigurer 配置。

隨便舉幾例：

HttpSecurity 中有大量類似的方法，過濾器鏈中的過濾器就是這樣一個一個配置的。我就不一一介紹了。

每個配置方法的結尾都會來一句 getOrApply，這個是幹嘛的？

getConfigurer 方法是在它的父類 中定義的，目的就是去查看當前這個 xxxConfigurer 是否已經配置過了。

如果當前 xxxConfigurer 已經配置過了，則直接返回，否則調用 apply 方法，這個 apply 方法最終會調用到 #add 方法，將當前配置 configurer 收集起來。

HttpSecurity 中還有一個 addFilter 方法：

這個 addFilter 方法的作用，主要是在各個 xxxConfigurer 進行配置的時候，會調用到這個方法，（xxxConfigurer 就是用來配置過濾器的），把 Filter 都添加到 fitlers 變數中。

最終在 HttpSecurity 的 performBuild 方法中，構建出來一個過濾器鏈：

先給過濾器排序，然後構造 DefaultSecurityFilterChain 對象。

好啦，這就是 HttpSecurity 的一個大致工作流程。把握住了這個工作流程，剩下的就只是一些簡單的重復的 xxxConfigurer 配置了，松哥就不再啰嗦啦。

如果小夥伴們覺得有收獲，記得點個在看鼓勵下松哥哦～