- 1. 背景
- 2. 概念
- 2.1. 使用场景
- 2.2. 优缺点
- 2.2.1. 优点
- 2.2.2. 缺点
- 3. 模式结构
- 3.1. 对象定义
- 3.1.1. Handler抽象处理者
- 3.1.2. ConcreteHandler
- 3.1.3. Client
- 3.2. 传统样例
- 3.2.1. 抽象处理
- 3.2.2. 实际处理
- 3.2.3. 客户端
- 3.3. 进阶实现
- 3.3.1. 定义处理器实体
- 3.3.2. 枚举
- 3.3.3. 获取处理者
- 3.3.4. 抽象处理者
- 3.3.5. 实际处理者
- 3.3.6. 抽象工厂
- 3.3.7. 客户端
- 3.3.8. 执行效果
- 3.3.9. 小结
- 3.1. 对象定义
[图片上传失败...(image-8481c3-1659671734777)]
1. 背景
近期我有个需求，需要实现类似流程功能。我们开发人员本身条件限制，他使用原始的数据库中间状态来实现，但是代码堆的非常多、上下文逻辑很混乱、BUG 多，没有达到预期设定的要求。
事后，我想了下，如果换做是我，我该怎么做？
分析此类业务的特点，流程，我想到了 责任链 。
2. 概念
责任链模式（Chain of Responsibility）是设计模式的一种，属于 行为型设计模式 。
[图片上传失败...(image-c1a68-1659671734777)]
为请求创建了一个链，请求在链上被处理。通常某个处理器如果不能处理该请求，那么它会把相同的请求传给链上的下一个处理器。
2.1. 使用场景
如果一个请求需要经过多个处理步骤，将多个处理的步骤抽象成一条 执行链 ，那么便可以使用责任链模式。
责任链的使用场景一般有：
- 向多处理器提交一个请求，最终运行时只会有一个处理器处理请求；
- 向多处理器提交一个请求，所有处理器都会处理请求。
在现实中，我们很多场景都使用到了责任链模式。
-
RBAC模型 ：多条件流程判断 -
ERP系统流程审批：总经理、销售总监、产品部经理、项目组长 -
Java MVC过滤器的底层实现Filter
2.2. 优缺点
2.2.1. 优点
- 降低耦合度。它将请求的发送者和接收者解耦
- 简化了对象，使得对象不需要知道链的结构
- 增强给对象指派职责的灵活性，允许动态地新增或者删除责任链
- 增加新的请求处理类方便
2.2.2. 缺点
- 不能保证请求一定被接收；
- 系统性能将受到一定影响，调试时不方便，可能会造成循环调用
3. 模式结构
3.1. 对象定义
3.1.1. Handler抽象处理者
handler 定义处理请求的接口， handler 知道下一个处理者是谁，如果自己无法处理请求，就转给下一个处理者。
3.1.2. ConcreteHandler
具体的处理者是处理请求的具体角色
3.1.3. Client
请求者角色，就是向第一个具体的 handler 发送请求的角色，并连接好责任链。
[图片上传失败...(image-aee85a-1659671734777)]
3.2. 传统样例
3.2.1. 抽象处理
public abstract class AbstractHandler {
/**
* 定义下一用当前抽象类来接收
*/
protected AbstractHandler next;
public void setNext(AbstractHandler next) {
this.next = next;
}
public abstract int handler();
}
3.2.2. 实际处理
@Slf4j
public class FirstPassHandler extends AbstractHandler{
static final int FIRST_SCOPE = 70;
@Override
public int handler() {
log.error("第一环节处理");
int score = first();
if(score>=FIRST_SCOPE){
log.error("处理完毕，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了，交由下一环节处理");
}
return score;
}
private int first(){
return FIRST_SCOPE;
}
}
@Slf4j
public class SecondPassHandler extends AbstractHandler{
static final int SECOND_SCOPE = 80;
@Override
public int handler() {
log.error("第二环节处理");
int score = second();
if(score>=SECOND_SCOPE){
log.error("处理完毕，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了，交由下一环节处理");
}
return score;
}
private int second(){
return SECOND_SCOPE;
}
}
@Slf4j
public class ThirdPassHandler extends AbstractHandler{
static final int THIRD_SCOPE = 90;
@Override
public int handler() {
log.error("第三环节处理");
int score = third();
if(score>=THIRD_SCOPE){
log.error("处理完毕，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了，交由下一环节处理");
}
return score;
}
private int third(){
return THIRD_SCOPE;
}
}
3.2.3. 客户端
@DisplayName("责任链模式")
@Test
public void testChain() {
FirstPassHandler firstPassHandler = new FirstPassHandler();
SecondPassHandler secondPassHandler = new SecondPassHandler();
ThirdPassHandler thirdPassHandler = new ThirdPassHandler();
firstPassHandler.setNext(secondPassHandler);
secondPassHandler.setNext(thirdPassHandler);
firstPassHandler.handler();
}
这种方式，有点不好，每次都需要 客户端 自己维护这样的关系，不是非常合理，而且很多时候人家客户端不想知道这个过程。
3.3. 进阶实现
在上述样例中，我们可以将关系维护到配置文件中或者一个枚举中。此处用枚举作为实现方式来演示如何动态的配置请求链并且将每个请求者形成一条调用链。
|-- dao
| |-- FilterDao.java
| `-- FilterImpl.java
|-- entity
| `-- FilterEntity.java
|-- enums
| `-- FilterEnum.java
|-- factory
| `-- FilterHandlerEnumFactory.java
|-- handler
| |-- AbstractFilterHandler.java
| |-- FirstFilterHandler.java
| |-- SecondFilterHandler.java
| `-- ThirdFilterHandler.java
3.3.1. 定义处理器实体
@Data
@AllArgsConstructor
public class FilterEntity {
/**
* handlerId
*/
private Integer handlerId;
/**
* 处理器名称
*/
private String name;
/**
* 处理器 包名 + 类名
*/
private String conference;
/**
* 上一个处理器
*/
private Integer preHandlerId;
/**
* 下一个处理器
*/
private Integer nextHandlerId;
}
3.3.2. 枚举
public enum FilterEnum {
FIRST_HANDLER(new FilterEntity(1, "首要处理环节", FirstFilterHandler.class.getName(), null, 2)),
SECOND_HANDLER(new FilterEntity(2, "二次处理环节", SecondFilterHandler.class.getName(), 1, 3)),
THIRD_HANDLER(new FilterEntity(3, "三次处理环节", ThirdFilterHandler.class.getName(), 2, null));
FilterEntity filterEntity;
public FilterEntity getGameEntity() {
return filterEntity;
}
FilterEnum(FilterEntity filterEntity) {
this.filterEntity = filterEntity;
}
}
这里将处理环节利用枚举，将前后依赖顺序进行定义。
3.3.3. 获取处理者
public interface FilterDao {
/**
* 根据 handlerId 获取配置项
* @param handlerId
* @return
*/
FilterEntity getGameEntity(Integer handlerId);
/**
* 获取第一个处理者
* @return
*/
FilterEntity getFirstGameEntity();
}
public class FilterImpl implements FilterDao {
/**
* 初始化，将枚举中配置的handler初始化到map中，方便获取
*/
private static Map gatewayEntityMap = new HashMap<>();
static {
FilterEnum[] values = FilterEnum.values();
for (FilterEnum value : values) {
FilterEntity gatewayEntity = value.getGameEntity();
gatewayEntityMap.put(gatewayEntity.getHandlerId(), gatewayEntity);
}
}
@Override
public FilterEntity getGameEntity(Integer handlerId) {
return gatewayEntityMap.get(handlerId);
}
@Override
public FilterEntity getFirstGameEntity() {
for (Map.Entry entry : gatewayEntityMap.entrySet()) {
FilterEntity value = entry.getValue();
// 没有上一个handler的就是第一个
if (value.getPreHandlerId() == null) {
return value;
}
}
return null;
}
}
3.3.4. 抽象处理者
public abstract class AbstractFilterHandler {
/**
* 定义下一用当前抽象类来接收
*/
protected AbstractFilterHandler next;
public void setNext(AbstractFilterHandler next) {
this.next = next;
}
public abstract int handler();
}
3.3.5. 实际处理者
@Slf4j
public class FirstFilterHandler extends AbstractFilterHandler {
static final int FIRST_SCOPE = 70;
@Override
public int handler() {
log.error("第一环节处理");
int score = first();
if(score>=FIRST_SCOPE){
log.error("处理完毕，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了，交由下一环节处理");
}
return score;
}
private int first(){
return FIRST_SCOPE;
}
}
@Slf4j
public class SecondFilterHandler extends AbstractFilterHandler {
static final int SECOND_SCOPE = 80;
@Override
public int handler() {
log.error("第二环节处理");
int score = second();
if(score>=SECOND_SCOPE){
log.error("处理完毕，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}else{
log.error("处理不了，交由下一环节处理");
}
return score;
}
private int second(){
return SECOND_SCOPE;
}
}
@Slf4j
public class ThirdFilterHandler extends AbstractFilterHandler {
static final int THIRD_SCOPE = 90;
@Override
public int handler() {
log.error("第三环节处理");
int score = third();
if(score>=THIRD_SCOPE){
log.error("处理完毕，交由下一环节处理");
}else{
log.error("处理不了，交由下一环节处理");
if(this.next != null){
return this.next.handler();
}
}
return score;
}
private int third(){
return THIRD_SCOPE;
}
}
3.3.6. 抽象工厂
@Slf4j
public class FilterHandlerEnumFactory {
private static FilterDao filterDao = new FilterImpl();
/**
* 提供静态方法，获取第一个handler
*
* @return AbstractFilterHandler
* @author Sam
* @date 2022/8/4-23:50
**/
public static AbstractFilterHandler getFirstHandler() {
FilterEntity firstGatewayEntity = filterDao.getFirstGameEntity();
AbstractFilterHandler firstAbstractFilterHandler = newGatewayHandler(firstGatewayEntity);
if (firstAbstractFilterHandler == null) {
return null;
}
FilterEntity tempFilterEntity = firstGatewayEntity;
Integer nextHandlerId = null;
AbstractFilterHandler tempHandler = firstAbstractFilterHandler;
// 迭代遍历所有handler，以及将它们链接起来
while ((nextHandlerId = tempFilterEntity.getNextHandlerId()) != null) {
FilterEntity filterEntity = filterDao.getGameEntity(nextHandlerId);
AbstractFilterHandler abstractFilterHandler = newGatewayHandler(filterEntity);
tempHandler.setNext(abstractFilterHandler);
tempHandler = abstractFilterHandler;
tempFilterEntity = filterEntity;
log.warn("Init GatewayHandler", tempFilterEntity.getHandlerId());
}
// 返回第一个handler
return firstAbstractFilterHandler;
}
/**
* 反射实体化具体的处理者
*
* @param filterEntity
* @return AbstractFilterHandler
*/
private static AbstractFilterHandler newGatewayHandler(FilterEntity filterEntity) {
try {
String clazzName = filterEntity.getConference();
log.error(clazzName);
Class clazz = Class.forName(clazzName);
return (AbstractFilterHandler) clazz.newInstance();
} catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
3.3.7. 客户端
@DisplayName("责任链模式-工厂")
@Test
public void testChainFactory() {
AbstractFilterHandler handler = FilterHandlerEnumFactory.getFirstHandler();
handler.handler();
}
3.3.8. 执行效果
2022-08-05 11:25:37,670 ERROR (GameHandlerEnumFactory.java:56)- io.github.rothschil.design.chain.en.handler.FirstPassHandler
2022-08-05 11:25:37,673 ERROR (GameHandlerEnumFactory.java:56)- io.github.rothschil.design.chain.en.handler.SecondPassHandler
2022-08-05 11:25:37,673 WARN (GameHandlerEnumFactory.java:42)- Init GatewayHandler
2022-08-05 11:25:37,675 ERROR (GameHandlerEnumFactory.java:56)- io.github.rothschil.design.chain.en.handler.ThirdPassHandler
2022-08-05 11:25:37,675 WARN (GameHandlerEnumFactory.java:42)- Init GatewayHandler
2022-08-05 11:25:37,675 ERROR (FirstPassHandler.java:17)- 第一环节处理
2022-08-05 11:25:37,676 ERROR (FirstPassHandler.java:20)- 处理完毕，交由下一环节处理
2022-08-05 11:25:37,676 ERROR (SecondPassHandler.java:17)- 第二环节处理
2022-08-05 11:25:37,676 ERROR (SecondPassHandler.java:20)- 处理完毕，交由下一环节处理
2022-08-05 11:25:37,676 ERROR (ThirdPassHandler.java:17)- 第三环节处理
2022-08-05 11:25:37,676 ERROR (ThirdPassHandler.java:20)- 处理完毕，交由下一环节处理
2022-08-05 11:25:37,680 INFO (TestDesign.java:64)- [AfterAll] 总共耗时=16 毫秒
3.3.9. 小结
通过枚举以及抽象工厂，我们将每个处理器连接起来，让客户端只关系自己的诉求部分，具体实现逻辑交由枚举来定义。这样做简化客户端的业务。相对来说比较友好，而且容易拓展。