建造者模式、責任鏈模式與OKHttp

1.簡介

學習構(gòu)造模式不僅可以提高代碼質(zhì)量，也有助與我們閱讀各類庫的源碼，因為優(yōu)秀的庫中充斥著各種設(shè)計模式。恰巧今天學習了建造者模式和責任鏈模式，于是通過分析OkHttp源碼來鞏固知識。

2.建造者模式

理解：構(gòu)造者中實現(xiàn)多個構(gòu)造方法，可以精細化構(gòu)造出需要的對象，同時不必知道構(gòu)造細節(jié)

建造者模式VS抽象工廠模式

建造者模式：針對某一個產(chǎn)品進行精細化構(gòu)造，如定制一個手機。
抽象工廠模式：針對某一系列產(chǎn)品家族，如華為P系列手機，每個工廠只負責生產(chǎn)一個型號的手機。

需求：根據(jù)玩家輸入?yún)?shù)生成一個星球
1)定義星球類

//星球類
class World(val water: String, val land:String, val biological:String){
    init {
        println("世界生成，水資源:$water, 陸地:$land，物種:$biological")
    }
}

2)定義構(gòu)造者接口，實現(xiàn)構(gòu)造者類

//構(gòu)造者接口
interface Build{

    //構(gòu)建水源
    fun buildWater(water: String):Build

    //構(gòu)建陸地
    fun buildLand(land: String):Build

    //構(gòu)建生物
    fun buildBiologcial(biological: String):Build

    //構(gòu)建世界
    fun buildWorld():World
}

//具體Build，即ConcreteBuilder
class WorldBuild : Build{

    var water = ""
    var land = ""
    var biological = ""

    override fun buildWater(water: String):Build {
        this.water = water
        return this
    }

    override fun buildLand(land: String):Build {
        this.land = land
        return this
    }

    override fun buildBiologcial(biological: String):Build {
        this.biological = biological
        return this
    }

    override fun buildWorld(): World {
        return World(water, land, biological)
    }
}

3)調(diào)用

fun main(args:Array<String>){
    val builder = WorldBuild()
    val world = builder.buildWater("豐富")
            .buildLand("稀少")
            .buildBiologcial("豐富")
            .buildWorld()
}

4)輸出


image.png

我們可以看到，通過Builder對象內(nèi)部的一系列放法，可以定制一個符合需求星球。我們甚至可以將Build類作為Product的靜態(tài)內(nèi)部類，借助Build構(gòu)建Product，這個在最后實戰(zhàn)時會提到。

3.責任鏈模式

理解：多個對象形成鏈，請求在上傳遞，每個對象處理后傳個下個對象。最后結(jié)果沿著鏈返回。

以上是個人理解，詳細可以去查百度
參考博客:https://www.cnblogs.com/ysw-go/p/5432921.html
我們先來定義一個簡單的需求：
（1）過濾掉句子中的敏感內(nèi)容
（2）替換html標簽
分析：我們需要定義過濾器，然后將過濾器加入List中，然后依次取用對句子進行過濾。

2）定義請求類和響應類

//響應類
class Response(var responseStr:String){}

//請求類
class Request(var requestStr:String){}

3）定義過濾器

//過濾器接口
interface Filetr{
    fun doFiletr(request: Request, response: Response, chain:FiletrChain): Response
}

//HTML過濾器
class HTMLFilter : Filetr{
    override fun doFiletr(request: Request, response: Response, chain: FiletrChain): Response {
        //將"<>"換成"[]"
        request.requestStr = "HTMLFilter---" + request.requestStr
                .replace("<","[")
                .replace(">", "]") + "---HTMLFilter"
        //通過過濾器鏈調(diào)用下一個過濾器
        return chain.proceed(request, response, chain)
    }
}
//敏感詞過濾器
class SenstiveFilter:Filetr{
    override fun doFiletr(request: Request, response: Response, chain: FiletrChain): Response {
        request.requestStr = "SenstiveFilter---" + request.requestStr
                .replace("敏感詞","")
                .replace("暴恐", "") + "---SenstiveFilter"
        return chain.proceed(request, response, chain)
    }
}

4）定義過濾器鏈


class FiletrChain{
    //將List封裝一起來，方便操作
    private val filters = ArrayList<Filetr>()

    private var index = 0

    //添加過濾器
    fun addFilter(f:Filetr):FiletrChain{
        filters.add(f)
        return this
    }
    //用list中的過濾器進行過濾
    fun proceed(request: Request, response: Response, chain:FiletrChain): Response{
        //判斷是否過濾完成
        if (index == filters.size){
            response.responseStr += request.requestStr
            return response
        }
        //依次調(diào)用下一個過濾器
        val f = filters[index]
        index++

        return f.doFiletr(request, response, chain)
    }
}

5）使用

fun main(args:Array<String>){
    val msg = "<Html>，敏感詞，吃飯，暴恐，旅游"
    val request = Request(msg)
    var respone = Response("response:")

    val filerChain = FiletrChain()
    respone = filerChain.addFilter(HTMLFilter())
            .addFilter(SenstiveFilter())
            .proceed(request, respone, filerChain)
    println(respone.responseStr)
}

6）輸出


image.png

4.實戰(zhàn)：模擬OKHttp攔截器鏈式調(diào)用

下面我們通過仿寫OKHttp中的鏈式調(diào)用來鞏固一下上面的知識。
1)首先用建造者模式來寫request類，寫的略微像點樣子，如下：

//請求類
class Request(builder: Builder) {
    var requestStr:String
    private var url:String? = null
    private var method:String? = null

    init {
        this.requestStr = builder.requestStr
        this.url = builder.url
        this.method = builder.method
    }

    //靜態(tài)內(nèi)部類
    class Builder{
        var requestStr = ""
        var url:String? = null
        var method:String? = null

        init {
            this.method = "GET"
        }

        fun url(url:String):Builder{
            this.url = url
            return this
        }
        fun requestStr(requestStr:String):Builder{
            this.requestStr = requestStr
            return this
        }
        fun build():Request{
            if (url == null) throw IllegalStateException("url == null")
            return Request(this)
        }
    }
}

//調(diào)用
fun main(args:Array<String>){
    val request = Request.Builder()
            .url("url")
            .build()
}

像okHttp一樣，我們要獲取一個request時，只需要通過Builder()方法，鏈式調(diào)用來傳入?yún)?shù)，最后通過.build()來建造一個request對象。建造者模式代碼完成，還是挺簡單的，下面我們來實現(xiàn)okhHttp中的責任鏈。

2)拿到OKHttp中Interceptor和Chain的定義，直接復制如下

interface Interceptor{
    fun intercept(chain:Chain): Response

    interface Chain{
        fun request(): Request

        fun proceed(request: Request): Response
    }
}

3)將整條責任鏈封裝

//攔截器鏈
class InterceptorChain(val interceptors:List<Interceptor>, var index:Int, val request: Request):Interceptor.Chain{
    override fun request(): Request {
        return request
    }

    //1.調(diào)用index位置的攔截器進行處理，返回處理的結(jié)果
    override fun proceed(request: Request): Response {
        //檢查是否有對應的攔截器
        if (index >= interceptors.size){
            throw  AssertionError()
        }
        //獲取當前鏈位置對應的攔截器
        val interceptor = interceptors[index]
        //2.獲取下一個鏈，將攔截器集合傳入，下標+1指向下一個攔截器
        val next = InterceptorChain(interceptors, index+1, request)
        //3.當前攔截器進行攔截處理,將攔截器鏈傳入
        val response = interceptor.intercept(next)
        //do check for response

        //返回index+1位置攔截器處理后的結(jié)果
        return response
    }
}

主要有兩個方法:
request():返回一個請求Request.
proceed():調(diào)用當前位置攔截器進行攔截，并獲取下一個攔截器
4)定義攔截器

//向服務器發(fā)送請求的攔截器
class CallServerInterceptor : Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {
        //模擬向服務器發(fā)送請求，獲取返回數(shù)據(jù)
        return Response("<Html>，敏感詞，吃飯，暴恐，旅游")
    }

}

//Html攔截器
class HTMLInterceptor : Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {

        val oldRequest = chain.request()
        //do something

        val newRequest = oldRequest

        //4.調(diào)用鏈中下一個攔截器，獲取處理后的結(jié)果
        val response = chain.proceed(newRequest)

        //處理結(jié)果，返回給上一個攔截器
        response.responseStr = response.responseStr
                .replace("<", "[")
                .replace(">", "]")
        return response
    }
}

//敏感詞攔截器
class SenstiveInterceptor : Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {

        val response = chain.proceed(chain.request())

        response.responseStr = response.responseStr
                .replace("敏感詞","")
                .replace("暴恐", "")
        return response
    }
}

這里定義了三個攔截器，可在調(diào)用下個攔截器之前對request進行處理；或者在下一個攔截器處理后，對結(jié)果進行處理，這里就對應不同的過濾條件。
5)仿寫一個call,添加一些默認攔截器

//封裝默認攔截器
class Call(val originalRequest: Request){
    @Throws(IOException::class)
    fun getResponseWithInterceptorChain(): Response {
        val interceptors = ArrayList<Interceptor>()
        //添加攔截器,可以暴露方法，以添加自定義攔截器
        interceptors.add(HTMLInterceptor())
        interceptors.add(SenstiveInterceptor())
        interceptors.add(CallServerInterceptor())
        val chain = InterceptorChain(interceptors, 0, originalRequest)
        return chain.proceed(originalRequest)
    }
}

我們可以在call中，添加一些必備的攔截器，如CallServerInterceptor ,同時可以暴露方法，給用戶添加自定攔截器。
6)整體使用：

fun main(args:Array<String>){
    val request = Request.Builder()
            .url("url")
            .build()
    val call = Call(request)
    val response = call.getResponseWithInterceptorChain()
    println(response.responseStr)
}

先通過建造者模式獲取request，然后實例化call對象，調(diào)用getResponseWithInterceptorChain()，使得request沿著攔截器鏈往下傳遞，最后到達CallServerInterceptor 發(fā)起網(wǎng)絡請求。response 再沿著鏈返回，每個攔截器對response進行處理。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容