1.简介
学习构造模式不仅可以提高代码质量，也有助与我们阅读各类库的源码，因为优秀的库中充斥着各种设计模式。恰巧今天学习了建造者模式和责任链模式，于是通过分析OkHttp源码来巩固知识。
2.建造者模式
理解：构造者中实现多个构造方法，可以精细化构造出需要的对象，同时不必知道构造细节
建造者模式VS抽象工厂模式
建造者模式：针对某一个产品进行精细化构造，如定制一个手机。
抽象工厂模式：针对某一系列产品家族，如华为P系列手机，每个工厂只负责生产一个型号的手机。
需求：根据玩家输入参数生成一个星球
1)定义星球类
//星球类
class World(val water: String, val land:String, val biological:String){
init {
println("世界生成，水资源:$water, 陆地:$land，物种:$biological")
}
}
2)定义构造者接口，实现构造者类
//构造者接口
interface Build{
//构建水源
fun buildWater(water: String):Build
//构建陆地
fun buildLand(land: String):Build
//构建生物
fun buildBiologcial(biological: String):Build
//构建世界
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)调用
fun main(args:Array<String>){
val builder = WorldBuild()
val world = builder.buildWater("丰富")
.buildLand("稀少")
.buildBiologcial("丰富")
.buildWorld()
}
4)输出
image.png
我们可以看到，通过Builder对象内部的一系列放法，可以定制一个符合需求星球。我们甚至可以将Build类作为Product的静态内部类，借助Build构建Product，这个在最后实战时会提到。
3.责任链模式
理解：多个对象形成链，请求在上传递，每个对象处理后传个下个对象。最后结果沿着链返回。
以上是个人理解，详细可以去查百度
参考博客:https://www.cnblogs.com/ysw-go/p/5432921.html
我们先来定义一个简单的需求：
（1）过滤掉句子中的敏感内容
（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"
//通过过滤器链调用下一个过滤器
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
}
//依次调用下一个过滤器
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.实战：模拟OKHttp拦截器链式调用
下面我们通过仿写OKHttp中的链式调用来巩固一下上面的知识。
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
}
//静态内部类
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)
}
}
}
//调用
fun main(args:Array<String>){
val request = Request.Builder()
.url("url")
.build()
}
像okHttp一样，我们要获取一个request时，只需要通过Builder()方法，链式调用来传入参数，最后通过.build()来建造一个request对象。建造者模式代码完成，还是挺简单的，下面我们来实现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.调用index位置的拦截器进行处理，返回处理的结果
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位置拦截器处理后的结果
return response
}
}
主要有两个方法:
request():返回一个请求Request.
proceed():调用当前位置拦截器进行拦截，并获取下一个拦截器
4)定义拦截器
//向服务器发送请求的拦截器
class CallServerInterceptor : Interceptor{
override fun intercept(chain: Interceptor.Chain): Response {
//模拟向服务器发送请求，获取返回数据
return Response("<Html>，敏感词，吃饭，暴恐，旅游")
}
}
//Html拦截器
class HTMLInterceptor : Interceptor{
override fun intercept(chain: Interceptor.Chain): Response {
val oldRequest = chain.request()
//do something
val newRequest = oldRequest
//4.调用链中下一个拦截器，获取处理后的结果
val response = chain.proceed(newRequest)
//处理结果，返回给上一个拦截器
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
}
}
这里定义了三个拦截器，可在调用下个拦截器之前对request进行处理；或者在下一个拦截器处理后，对结果进行处理，这里就对应不同的过滤条件。
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对象，调用getResponseWithInterceptorChain()，使得request沿着拦截器链往下传递，最后到达CallServerInterceptor 发起网络请求。response 再沿着链返回，每个拦截器对response进行处理。
