04.设计模式之责任链模式
什么是责任链模式
链表数据机构:
客户端发出一个请求,链上的对象都有机会来处理这一个请求,而客户端不需要知道谁是具体的处理对象。这样就实现了请求者和接受者之间的解耦,并且在客户端可以实现实现动态的组合职责链。使编程更有灵活性。
定义: 使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。实际就是一个递归调用。
要点主要是:
- 有多个对象共同对一个任务进行处理
- 这些对象使用链式存储结构,形成一个链,每个一个对象知道自己的下一个对象。
- 一个对象对任务进行处理,可以增加一些操作后将对象传递个下一个任务。也可以在此对象上结束任务的处理,并结束任务。
- 客户端负责组装链式结构,但是客户端不需要关心最终不需要关心最终是谁来处理了任务。
责任链模式的优缺点:
优点:
责任链模式的最主要功能是:动态组合,请求者和接受者解耦。
请求者和接受者松散耦合:请求者不需要知道接受者,也不需要知道如何处理,每个职责只负责自己的职责范围,其他的交给后继者。各个组件间完全解耦。
动态组合职责:职责链模式会把功能分散到单独的职责对象中,然后再使用时动态的组合形成链。从而可以灵活的分配职责对象,也可以灵活的添加改变对象职责。
缺点:
产生很多细粒度的对象,因为功能处理都分散到了单独的职责对象中,每个对象功能单一,要把整个流程处理完,需要很多职责对象。会产生大量的细粒度职责对象。
不一定能处理: 每个职责对象都只负责自己部分,这样就可以出现某个请求,即使把整个链走完都没有职责对象处理它,这样就需要提供默认处理,并且注意构造链的有效性。
责任链模式应用场景
- 多条件流程判断权限控制
- erp系统 流程审批
- java 过滤器的底层实现filter
- 工作流
比如:在java过滤器中客户端发送请求到客户端,过滤会经过参数过滤,sesson过滤,表单过滤,隐藏过滤,检测请求头过滤。
责任链模式应用场景:
网关权限控制责任链模式:
在网关作为微服务程序的入口,拦截客户端所有的请求实现权限控制
比如先判断Api接口限流,黑名单,用户会话,参数过滤。
Api接口限流-黑名单拦截--用户会话--参数过滤
责任链整合工厂模式:
GatewayHandler抽象角色;
package com.taotao.chain;
public abstract class GatewayHandler {
/**
* 处理流程
*/
public abstract void doServices();
/**
* 下一个nextGatewayHandler
*/
public GatewayHandler nextGatewayHandler;
/**
* 获取当前handler的下一个
*/
// public abstract void setNextGatewayHandler(GatewayHandler nextGatewayHandler);
public void setNextGatewayHandler(GatewayHandler nextGatewayHandler) {
this.nextGatewayHandler=nextGatewayHandler;
}
}
具体Handler实现
package com.taotao.chain.impl;
import com.taotao.chain.GatewayHandler;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class CurrentLimitHandler extends GatewayHandler {
@Override
public void doServices() {
log.info("<第一关api接口限流>");
//第一关放行 过了
nextGatewayHandler.doServices();
}
}
package com.taotao.chain.impl;
import com.taotao.chain.GatewayHandler;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class BlackLimitHandler extends GatewayHandler {
@Override
public void doServices() {
log.info("<<第二关 判断是否ip黑名单>");
nextGatewayHandler.doServices();
}
}
package com.taotao.chain.impl;
import com.taotao.chain.GatewayHandler;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ConversationLimitHandler extends GatewayHandler {
@Override
public void doServices() {
log.info("<<第三关 判断用户是否验证token信息>");
}
}
FactoryHandler
package com.taotao.chain.factory;
import com.taotao.chain.GatewayHandler;
import com.taotao.chain.impl.BlackLimitHandler;
import com.taotao.chain.impl.ConversationLimitHandler;
import com.taotao.chain.impl.CurrentLimitHandler;
public class FactoryHandler {
public static GatewayHandler getGatewayHandler() {
CurrentLimitHandler currentLimitHandler=new CurrentLimitHandler();
//1 设置黑名单BlackListHandler
BlackLimitHandler blackLimitHandler=new BlackLimitHandler();
blackLimitHandler.setNextGatewayHandler(new ConversationLimitHandler());
//2 设置api接口限流的handler下一个handler黑名单Handler
currentLimitHandler.setNextGatewayHandler(blackLimitHandler);
return currentLimitHandler;
}
public static void main(String[] args) {
GatewayHandler gatewayHandler=FactoryHandler.getGatewayHandler();
gatewayHandler.doServices();
}
}
责任链整合spring模式
IOC抽象工厂
package com.taotao.chain.factory;
import com.taotao.chain.GatewayHandler;
import com.taotao.chain.impl.BlackLimitHandler;
import com.taotao.chain.impl.ConversationLimitHandler;
import com.taotao.chain.impl.CurrentLimitHandler;
import com.taotao.utils.SpringUtils;
public class FactoryHandler {
public static GatewayHandler getGatewayHandler() throws Exception {
/* CurrentLimitHandler currentLimitHandler=new CurrentLimitHandler();
//1 设置黑名单BlackListHandler
BlackLimitHandler blackLimitHandler=new BlackLimitHandler();
blackLimitHandler.setNextGatewayHandler(new ConversationLimitHandler());
//2 设置api接口限流的handler下一个handler黑名单Handler
currentLimitHandler.setNextGatewayHandler(blackLimitHandler);*/
ConversationLimitHandler conversationLimitHandler = SpringUtils.getBean("conversationLimitHandler", ConversationLimitHandler.class);
BlackLimitHandler blackLimitHandler = SpringUtils.getBean("blackLimitHandler", BlackLimitHandler.class);
blackLimitHandler.setNextGatewayHandler(conversationLimitHandler);
// 2.设置api接口限流的Handler 下一个Handler 黑名单Handler
CurrentLimitHandler currentLimitHandler = SpringUtils.getBean("currentLimitHandler", CurrentLimitHandler.class);
currentLimitHandler.setNextGatewayHandler(blackLimitHandler);
return currentLimitHandler;
}
public static void main(String[] args) throws Exception {
GatewayHandler gatewayHandler=FactoryHandler.getGatewayHandler();
gatewayHandler.doServices();
}
}
具体Handler实现
package com.taotao.mapper;
import com.taotao.entity.GatewayHandlerEntity;
import org.apache.ibatis.annotations.Select;
public interface GatewayHandlerMapper {
/**
* 获取第一个GatewayHandler
*/
@Select("SELECT handler_name AS handlerName,handler_id AS handlerid ,prev_handler_id AS prevhandlerid ,next_handler_id AS nexthandlerid FROM gateway_handler WHERE prev_handler_id is null;;")
GatewayHandlerEntity getFirstGatewayHandler();
@Select("SELECT handler_name AS handlerName,handler_id AS handlerid ,prev_handler_id AS prevhandlerid ,next_handler_id AS nexthandlerid FROM gateway_handler WHERE handler_id=#{handlerId}")
GatewayHandlerEntity getByHandler(String handlerId);
}
package com.taotao.service;
import com.mysql.cj.log.Log;
import com.taotao.chain.GatewayHandler;
import com.taotao.chain.factory.FactoryHandler;
import com.taotao.manage.GatewayHandlerManage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class TestChainService {
@Autowired
private GatewayHandlerManage gatewayHandlerManage;
/*
*测试责任链
*/
@RequestMapping("/testChain")
public String testChain() {
try {
/* GatewayHandler gatewayHandler = FactoryHandler.getGatewayHandler();
gatewayHandler.doServices();*/
GatewayHandler gatewayHandler = gatewayHandlerManage.getFirstGatewayHandler();
gatewayHandler.doServices();
} catch (Exception e) {
log.error("<权限不足,中间部分环节没有通过>");
return "fail";
}
//业务代码 更新doService方法中某一个环节 ,没有过的情况就不会执行
/**
* 封装的方法
* 1,方法上加上返回值 拦截器(多拦截器)true
* 2,抛出异常
*/
return "业务代码";
}
}
package com.taotao.utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class SpringUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringUtils.applicationContext = applicationContext;
}
//获取applicationContext
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
//通过name获取 Bean.
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
//通过class获取Bean.
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
//通过name,以及Clazz返回指定的Bean
public static <T> T getBean(String name, Class<T> clazz) {
try {
return getApplicationContext().getBean(name, clazz);
} catch (Exception e) {
log.error("<e:{}>", e);
return null;
}
}
}
package com.taotao.manage;
import com.taotao.chain.GatewayHandler;
import com.taotao.entity.GatewayHandlerEntity;
import com.taotao.mapper.GatewayHandlerMapper;
import com.taotao.utils.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class GatewayHandlerManage {
@Autowired
private GatewayHandlerMapper gatewayHandlerMapper;
public GatewayHandler getFirstGatewayHandler() throws Exception {
GatewayHandlerEntity firstGatewayHandler = gatewayHandlerMapper.getFirstGatewayHandler();
//先查询第一个gatewayHandler
if (firstGatewayHandler == null) {
//db没有配置第一个
log.error("没有配置我们的第一个gatewayHandler");
return null;
}
String firstHandlerId = firstGatewayHandler.getHandlerId();
if (Strings.isEmpty(firstHandlerId)) {
log.error("没有配置我们的第一个firstHandlerId");
return null;
}
//2 继续 判断如果有下一个gatewayHandler直接调用gatewayHandler.setGatewayHandler();
GatewayHandler firstHandler = SpringUtils.getBean(firstHandlerId, GatewayHandler.class);
String nextHandlerId = firstGatewayHandler.getNextHandlerId();
GatewayHandler tempHandlers=firstHandler;
while (Strings.isNotBlank(nextHandlerId)) {
GatewayHandler nextGatewayHandler = SpringUtils.getBean(nextHandlerId, GatewayHandler.class);
tempHandlers.setNextGatewayHandler(nextGatewayHandler);
//根据nextGatewayHandler查询数据库db信息得到下一个GatewayHandler信息
GatewayHandlerEntity nextGatewayHandlerEntity = gatewayHandlerMapper.getByHandler(nextHandlerId);
nextHandlerId = nextGatewayHandlerEntity.getNextHandlerId();
tempHandlers=nextGatewayHandler;
}
return firstHandler;
}
}
标签:GatewayHandler,chain,模式,责任,taotao,import,com,public
From: https://www.cnblogs.com/hm201402/p/17055576.html