责任链模式与 OkHttp

• 什么是责任链模式
• OkHttp中责任链模式的实现

一、什么是责任链模式

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止

• 多个对象都有机会处理请求
• 对象连成一条链
• 沿着链传递请求
• 最后返回结果

二、OkHttp 中责任链模式的实现

在 OkHttp 中，对象指的是拦截器对象，所以

• 多个拦截器对象对请求进行拦截处理
• 将拦截器对象连成一条链
• 沿着链传递请求
• 最后返回结果

具体参考 RealCall # getResponseWithInterceptorChain() 和 RealInterceptorChain # proceed()

1. 多个拦截器对象对请求进行拦截处理，抽象出拦截器对象的公共方法

interface Interceptor {
    fun intercept(request: Request): Response
}

请求会沿着链进行传递的，也就意味着链应该持有请求的引用，拦截器应该拦截链，通过链获取请求

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

class Chain(val request: Request) 

2. 将拦截器对象连成一条链，意味着链也持有这些拦截器对象的引用，用 List 存储拦截器对象

class Chain(
        val request: Request,
        val interceptors: ArrayList<Interceptor>
) 

3. 用间接递归的方式沿着链传递请求，添加一个 index 索引，将链对象传给下一个拦截器对象，由下一个拦截器对象决定是否继续拦截请求

class Chain(
        val request: Request,
        val interceptors: ArrayList<Interceptor>,
        var index: Int
) {

    fun procceed(request: Request): Response {
        val next = Chain(request, interceptors, index + 1)
        return interceptors[index].intercept(next)
    }

}

4. 具体拦截器，根据链类获取请求，并做对应的处理。最后需要提供一个的拦截器，停止请求在链上的传递

class AInterceptor : Interceptor {
    override fun intercept(chain: Chain): Response {
        println("intercepted by A")
        val request = chain.request
        return chain.procceed(request)
    }
}

class BInterceptor : Interceptor {
    override fun intercept(chain: Chain): Response {
        println("intercepted by B")
        val request = chain.request
        return chain.procceed(request)
    }
}

class FinalInterceptor : Interceptor {
    override fun intercept(chain: Chain): Response {
        println("intercepted by Final")
        return Response()
    }
}

fun main(args: Array<String>) {
    // interceptors
    val interceptors = ArrayList<Interceptor>()
    interceptors.add(AInterceptor())
    interceptors.add(BInterceptor())
    interceptors.add(FinalInterceptor())

    // 请求
    val request = Request()

    // 拦截器的链
    val chain = Chain(request, interceptors, 0)
    chain.procceed(request)
}

三、过滤器例子

多种过滤器过滤字符串，有数字过滤器，字母过滤器等，自由添加过滤器，最后得到过滤后的字符串

interface Filter {
    fun filter(chain: FilterChain): String
}

class FilterChain(
        val message: String,
        private val filters: ArrayList<Filter>,
        var index: Int
) {

    fun procceed(message: String): String {
        val next = FilterChain(message, filters, index + 1)
        return filters[index].filter(next)
    }
}

/**
 * 数字过滤器
 */
class NumberFilter : Filter {

    override fun filter(chain: FilterChain) : String{
        val message = chain.message
        val newMessage = message.replace("\\d+".toRegex(), "")
        println("filtered by NumberFilter: $newMessage")
        return chain.procceed(newMessage)
    }
}

/**
 * 字母过滤器
 */
class LetterFilter : Filter {
    override fun filter(chain: FilterChain) : String {
        val message = chain.message
        val newMessage = message.replace("[a-zA-Z]".toRegex(), "")
        println("filtered by LetterFilter: $newMessage")
        return chain.procceed(newMessage)
    }
}

class FinalFilter : Filter {
    override fun filter(chain: FilterChain) : String {
        val message = chain.message
        println("filtered by FinalFilter: $message")
        return message
    }
}

fun main(args: Array<String>) {
    val filters = arrayListOf(NumberFilter(), LetterFilter(), FinalFilter())
    val message = "wmj123你好啊"
    val filterChain = FilterChain(message, filters, 0)
    filterChain.procceed(message)
}