重修设计模式-行为型-责任链模式
将请求的发送和接收解耦,让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链,并沿着这条链传递这个请求,直到链上的某个接收对象能够处理它为止。
责任链模式(Chain of Responsibility Pattern)也叫职责链模式,通过将请求的处理分配给一系列的处理对象,这些处理对象通过链式结构组织起来,以实现对请求的灵活处理。比如,一个请求先经过 A 处理器处理,然后再把请求传递给 B 处理器,B 处理器处理完后再传递给 C 处理器,以此类推,形成一个链条,链条上的每个处理器承担各自的处理职责。
责任链模式的原理非常简单,有两种常用的实现。一种是使用链表来存储处理器,另一种是使用数组来存储处理器,后面一种实现方式更加简单。
1.链表方式
使用链表结构存储处理器,如果有处理器能处理该请求,就不继续往下传递;如果不能处理,则交由后面的处理器来处理。
//处理器
abstract class Handler {
var next: Handler? = null
abstract fun handle()
}
class Handler1: Handler() {
override fun handle() {
var handled = false
//doAction...
handled = Random.nextBoolean()
println("${javaClass.simpleName}处理逻辑... 处理结果:$handled")
//...
if (!handled && next != null) { //如果处理不了,交给下一个处理器
next?.handle()
}
}
}
class Handler2: Handler() {
override fun handle() {
var handled = false
//doAction...
handled = Random.nextBoolean()
println("${javaClass.simpleName}处理逻辑... 处理结果:$handled")
//...
if (!handled && next != null) {
next?.handle()
}
}
}
//处理器链
class HandlerChain {
var head: Handler? = null
var tail: Handler? = null
fun addHandle(handler: Handler) {
handler.next = null
if (head == null) {
head = handler
tail = handler
return
}
tail?.next = handler
tail = handler
}
fun handle() {
head?.handle()
}
}
//使用时:
fun main() {
val chain = HandlerChain()
chain.addHandle(Handler1())
chain.addHandle(Handler2())
chain.handle() //开始责任链调用
}
2.集合方式
使用集合存储所有处理器,调用时通过遍历来串联所有处理器,实现更加简单
//处理器
abstract class HandlerList {
abstract fun handle(): Boolean
}
class HandlerA : HandlerList() {
override fun handle(): Boolean {
var handled = false
//doAction...
handled = Random.nextBoolean()
println("${javaClass.simpleName}处理逻辑... 处理结果:$handled")
//...
//如果处理不了,交给下一个处理器
return handled
}
}
class HandlerB : HandlerList() {
override fun handle(): Boolean {
var handled = false
//doAction...
handled = Random.nextBoolean()
println("${javaClass.simpleName}处理逻辑... 处理结果:$handled")
//...
//如果处理不了,交给下一个处理器
return handled
}
}
//处理器链
class HandlerChainB {
private val chainList = mutableListOf<HandlerList>()
fun addHandle(handler: HandlerList) {
chainList.add(handler)
}
fun handle() {
for (filter in chainList) {
if (!filter.handle()) {
return
}
}
}
}
//调用处:
fun main() {
val chainB = HandlerChainB()
chainB.addHandle(HandlerA())
chainB.addHandle(HandlerB())
chainB.handle()
}
责任链模式可以将请求和处理分开,请求者无需知道处理流程,只关注处理结果;处理者只关注处理逻辑。两者解耦,提高了系统的灵活性和可扩展性。利用它们来提供框架的扩展点,能够让框架的使用者在不修改框架源码的情况下,基于扩展点定制化框架的功能。
传统的责任链定义是,如果处理器链上的某个处理器能够处理这个请求,那就不会继续往下传递请求。实际上,职责链模式还有一种变体,那就是请求会被所有的处理器都处理一遍,不存在中途终止的情况。比如责任链在网络请求的应用:Okhttp
责任链模式在 Okhttp 中的运用
Okhttp 是移动端网络请求的框架,它内部的网络请求实现就用到了责任链模式。具体实现方式是通过集合存储不同职责的拦截器,保证拦截器执行顺序,并通过递归调用的方式将每个拦截器串联起来,从而支持双向拦截:既能拦截客户端发送的请求,也能拦截服务器返回的响应。
getResponseWithInterceptorChain
是 Okhttp 进行网络请求,获取服务端响应结果的核心方法,会通过几个不同职责的拦截器拿到数据,源码如下:
Response getResponseWithInterceptorChain() throws IOException {
//装载不同职责的拦截器
List<Interceptor> interceptors = new ArrayList<>();
interceptors.addAll(client.interceptors()); //1.这是为客户端预留的拦截器扩展,可以拿到纯净的请求
interceptors.add(retryAndFollowUpInterceptor); //2.重试和重定向拦截器
interceptors.add(new BridgeInterceptor(client.cookieJar())); //3.处理请求和响应的Header,如Content-Length
interceptors.add(new CacheInterceptor(client.internalCache())); //4.缓存拦截器,如果有缓存则直接返回缓存数据
interceptors.add(new ConnectInterceptor(client)); //5.构建好TCP链接,确定好编/解码器的拦截器
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors()); //6.也是为客户端预留的拦截器扩展,可以拿到纯净的响应
}
interceptors.add(new CallServerInterceptor(forWebSocket)); //7.负责访问服务器并拿到响应结果
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
Response response = chain.proceed(originalRequest); //8.开始拦截器链式调用
if (retryAndFollowUpInterceptor.isCanceled()) {
closeQuietly(response);
throw new IOException("Canceled");
}
return response;
}
拦截器接口定义:
public interface Interceptor {
Response intercept(Chain chain) throws IOException;
interface Chain {
Request request();
Response proceed(Request request) throws IOException;
//...
}
}
具体实现:
public final class RealInterceptorChain implements Interceptor.Chain {
private final List<Interceptor> interceptors;
private final int index;
public RealInterceptorChain(List<Interceptor> interceptors, int index) {
this.interceptors = interceptors;
this.index = index;
}
@Override public Response proceed(Request request) throws IOException {
if (index >= interceptors.size()) throw new AssertionError();
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next); //自定义拦截器需要调用chain.proceed继续责任链的调用,通过递归方式穿起来了
//...
return response;
}
}
每个拦截器在内部会封装成 RealInterceptorChain
类型,它内部封装了网络的一些通用逻辑,这个可以忽略,内部还是调用了 intercept
方法传递给下一个拦截器,拦截器中又调用 chain.proceed
继续传递,通过递归的方式将拦截器链串联起来,达到双向拦截的效果,例如下面自定义的拦截器:
public final class CustomInterceptor implements Interceptor {
@Override public Response intercept(Chain chain) throws IOException {
//1.对请求进行处理,比如进行gzip压缩
Response networkResponse = chain.proceed(requestBuilder.build());
//2.对响应进行处理,比如gzip解压
return networkResponse;
}
}
总结
责任链模式是一种非常有用的设计模式,它通过链式结构来组织处理者,实现了请求的灵活处理和系统的可扩展性。
标签:...,拦截器,handle,handled,重修,interceptors,责任,处理器,设计模式 From: https://blog.csdn.net/weixin_39397471/article/details/142568857