设计模式系列文章 |
java设计模式解析(1) Observer观察者模式 |
| 主要内容 |
2、实现代码(Talk is cheap，Show me the code)
1、简述
Chain责任链模式在《设计模式之禅》定义： 使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条线，并沿着这条链传递该请求，直至有对象处理它为止。
责任链的核心在“链”，由“链”上所有的成员去处理请求并返回结果。 类图中各个角色定义如下：
- Client：客户端向发起请求，责任链对客户端透明
- Handler：责任链抽象类，负责定义处理逻辑以及组装责任链机制
- ConcreteHandler：责任链中的链由多个ConcreteHandler组装而成
结合上述给伪码：
==> Handler类
public abstract class Handler {
private Handler nextHandler ;
public final Response handlerMessage(Request request){
Response response = null ;
// 符合自己处理
if(this.getHandlerLevel().equals(request.getRequestLevel())){
response = this.echo(request) ;
}
// 交由其他人处理
else if (nextHandler != null) {
response = nextHandler.handlerMessage(request) ;
}
return response ;
}
// 组装责任链
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
// 模版方法 由具体的责任链实现者定义
protected abstract Level getHandlerLevel();
protected abstract Response echo(Request request);
}==> ConcreteHandler1、ConcreteHandler2、ConcreteHandler3三个类代码类似，都是实际责任链一员且通过继承Handler只需要实现自己的逻辑部分。
public class ConcreteHandler1 extends Handler {
@Override
protected Level getHandlerLevel() {
return null;
}
@Override
protected Response echo(Request request) {
return null;
}
}==> Client客户端发起请求 此时包含了责任链的组装和调用 实际可以增加代理简化Client操作
public class Client {
public static void main(String[] args) {
// 组装责任链
ConcreteHandler1 handler1 = new ConcreteHandler1() ;
ConcreteHandler2 handler2 = new ConcreteHandler2() ;
ConcreteHandler3 handler3 = new ConcreteHandler3() ;
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);
// 发起调用
Response response = handler1.handlerMessage(new Request()) ;
}以上伪码显示责任链模式基本代码实现，然后实际会依据情况有很多变化。如每个链条只处理部分数据并交由后链条执行，直至责任链的终止，甚至可以没有任何返回结果，接下来小节将展示一个自动组装的责任链demo。
2、实现代码(Talk is cheap，Show me the code)
根据责任链模式设计细想，在服务提供的前置增加一个责任链，以完成参数校验、签名、日志、监控、追踪等通用的任务。对于客户端完全透明，对于服务端利用JAVA SPI机制(DUBBO SPI思想)灵活组装配置责任链，而如果结合上强大的spring Bean容器，很容易完成服务框架的定制工作。
下面demo示例：
- Chain: 基本责任链中的链条定义
- ChainHandler：负责责任链的组装和调用逻辑
- ChainLoader：利用JAVA SPI机制，加载具体责任链实现
public interface Process<T> {
T doProcess() ;
}Process.java
package com.nancy.chain.auto;
public interface Chain {
int HIGHEST_ORDER = Integer.MIN_VALUE ;
int LOWEREST_ORDER = Integer.MAX_VALUE ;
/**
* 处理逻辑
* @param chainHandler 责任链组装
* @param pos 下一个触发下标
* @param process 实际处理逻辑
* @return T 返回结果
*/
<T> T doChain(ChainHandler chainHandler, int pos, Process<T> process) ;
/**
* 配置等级 越高优先级(越小) 越优先触发
* @param
* @return
*/
default Integer getOrder() {
return HIGHEST_ORDER ;
}
}Chain.java
public abstract class AbstractChain implements Chain, Cloneable {
}AbstractChain.java
public class ChainHandler extends AbstractChain {
private List<Chain> chains ;
public ChainHandler(List<Chain> chains){
this.chains = chains ;
chains.sort(Comparator.comparingInt(Chain::getOrder));
}
private boolean hasNext(int pos){
return chains.size()-1 >= pos ;
}
public List<Chain> getChains() {
return chains;
}
public void setChains(List<Chain> chains) {
this.chains = chains;
}
@Override
public <T> T doChain(ChainHandler chainHandler, int pos, Process<T> process) {
if(hasNext(pos)) return chainHandler.getChains().get(pos).doChain(chainHandler, ++pos, process);
return process.doProcess();
}
}ChainHandler.java
public class ChainLoader {
public static List<Chain> loadChain(){
List<Chain> chains = new ArrayList<>() ;
ServiceLoader<Chain> serviceLoader = ServiceLoader.load(Chain.class);
serviceLoader.forEach(chains::add);
return chains ;
}
}ChainLoader.java
package com.nancy.chain.auto.impl; import com.nancy.chain.auto.AbstractChain;
import com.nancy.chain.auto.Chain;
import com.nancy.chain.auto.ChainHandler;
import com.nancy.chain.auto.Process;
import java.util.List; public class HelloChain extends AbstractChain { @Override
public <T> T doChain(ChainHandler chainHandler, int pos, Process<T> process) {
System.out.println("HelloChain被触发了");
return chainHandler.doChain(chainHandler, pos, process);
} @Override
public Integer getOrder() {
return LOWEREST_ORDER-1 ;
} } package com.nancy.chain.auto.impl;
import com.nancy.chain.auto.AbstractChain;
import com.nancy.chain.auto.ChainHandler;
import com.nancy.chain.auto.Process; public class LogChain extends AbstractChain { @Override
public <T> T doChain(ChainHandler chainHandler, int pos, Process<T> process) {
System.out.println("LogChain被触发了");
return chainHandler.doChain(chainHandler, pos, process);
} @Override
public Integer getOrder() {
return LOWEREST_ORDER ;
} }
链条
JAVA SPI机制中的文件： META-INF/services/
com.nancy.chain.auto.impl.HelloChain
com.nancy.chain.auto.impl.LogChain
触发责任链：
package com.nancy.chain.auto;
import com.nancy.chain.auto.spi.ChainLoader;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 加载实现类
List<Chain> chains = ChainLoader.loadChain() ; // 触发
ChainHandler handler = new ChainHandler(chains) ;
Object res = handler.doChain(handler, 0, (Process<Object>) () -> 100) ; // 结果
System.out.println("结果" + res);
}
}
结果：
HelloChain被触发了
LogChain被触发了
结果100
3、注意点
- 责任链模式会依据情况有很多变化。可以只由某个“链条”处理请求，或者每个链条只处理部分数据并交由后链条执行，直至责任链的终止。可以有结果返回或者没有任何返回结果。
- 责任链模式可以解耦客户端和服务端，方便进行逻辑叠加。与观察者模式最大不同在于前者观察者是相互对等，之间没有影响。而后者由链条串联成线，链条之间可以建立起逻辑关系，完成某个功能。
- 责任链模式当“链条”很长的时候会存在很大性能问题，设计之初应该考虑长度问题，长度限制在一定范围内。 而责任链之间大多具有逻辑关系，不适用类似观察者模式用异步线程处理的方式。
触发责任链：
[Chùfā zérèn liàn:]
Trigger chain of responsibility:
Prototype原型模式
[Prototype yuánxíng móshì]
Prototype prototype model