责任链模式与其在Spring MVC中的应用

最新推荐文章于 2024-03-25 03:23:40 发布
最新推荐文章于 2024-03-25 03:23:40 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： # 设计模式 Spring
转载/复制请联系作者:snail.pu@foxmail.com
本文链接：https://blog.csdn.net/BigBug_500/article/details/104435391
版权

简单用例

   现有一开发场景，要求设计一个集团采购物品，不同金额交由不同领导审批的流程

   现有三级领导，金额在5000以下的，由部门领导审批；金额在10000以下的由院校级领导审批；金额在10000以上的，由校级领导审批。虽然使用 if-else 也能实现改功能，但是代码的可读性、可扩展性差，使用责任链设计模式，是面向对象的思维方式，符合“开闭原则”，具体实现的代码如下：
责任链调用发起者

 public static void main(String[] args) {
        PurchaseRequest purchaseRequest = new PurchaseRequest(1, 5001, 11);

        DepartmentApprover departmentApprover = new DepartmentApprover("部门审批者 张xx");
        CollegeApprover collegeApprover = new CollegeApprover("院系审批者 李xx");
        SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("校长审批 王xx");

        //设置责任链的下一个处理类(该段设置chain的逻辑，也可以在不同的approver子类中设置，但缺点是不易管理)
        departmentApprover.nextApprover=collegeApprover;
        collegeApprover.nextApprover=schoolMasterApprover;
        //为实现调用chain中任意一个处理类，都可以得到正确的结果，在这里构建一个环形链表
        schoolMasterApprover.nextApprover=departmentApprover;

        schoolMasterApprover.processRequest(purchaseRequest);//输出：请求编号：11 当前审批人名：院系审批者 李xx
    }

批准人抽象类

public abstract class Approver {
    Approver nextApprover;//下一个处理者
    String name;

    public Approver(String name) {
        this.name = name;
    }
    //交由子类去完善处理审批的逻辑
    public abstract void processRequest(PurchaseRequest purchaseRequest);
}

部门审批者、院系审批者、校长审批实现类

public class DepartmentApprover extends Approver{

    public DepartmentApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.price<=5000f){
            System.out.println("请求编号：" + purchaseRequest.id + " 当前审批人名：" + this.name);
        }else {
            nextApprover.processRequest(purchaseRequest);
        }
    }
}


public class CollegeApprover extends Approver {
    public CollegeApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if (purchaseRequest.price > 5000f && purchaseRequest.price <= 10000) {
            System.out.println("请求编号：" + purchaseRequest.id + " 当前审批人名：" + this.name);
        } else {
            nextApprover.processRequest(purchaseRequest);
        }
    }
}


public class SchoolMasterApprover extends Approver {
    public SchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.price>10000f){
            System.out.println("请求编号：" + purchaseRequest.id + " 当前审批人名：" + this.name);
        }else {
            nextApprover.processRequest(purchaseRequest);
        }
    }
}

使用责任链的注意事项和细节

  • 降低了流程中，调用链与链中某一节点执行逻辑的耦合度，提高了系统的灵活性
  • 当链中节点比较多时，系统的性能会受到影响，因此，可以考虑控制最长链节点。

设计模式是一种思想，在不同的地方，实现的方式可能不同，但大致的思想都是一致的，都是为了提高扩展性，可读性等原因。

实际生产用例

场景

  • 一个档案文件可能会经历移交、归档、长期保持环节，在经历不同的环节时需要执行四性检测
  • 在对一个档案文件的四性检测中，需要对真实、完整、可靠、安全性进行检测，且在四性中包含了103个检测项目。
  • 四性检测对每一个文件都需要过，检测项目按具体需求进行检测。

实现

整体实现思路：
  将四性的类通过执行链串起来，103个检测项目方法在对应的四性里，期间的执行结果通过 DetectionBuilder 类来保存。对于检测项目，通过反射去调用。

//detectionBuilder 中包含本次检测需要的多个信息
DetectionBuilder detectionBuilder = new DetectionBuilder( lists, dataInfo.getId(), arcfile, DetectionSegmentType.移交,
                adjunctFileInfos, fourDetectionRecordService.getLastDetection( dataInfo.getId(), DetectionSegmentType.移交 ) );
//调用入口。
Detection detection = FourDetectionFactory.getHandler().detectionChain( detectionBuilder ).getDetection();

FourDetectionFactory 类，获取、设置链顺序：

public class FourDetectionFactory {
    /**
     * 一个handler头
     */
    private static AbstractDetectionHandler allHandler;
    public static HashMap<String, String> codeAndMethodName;

    //初始化detection_code与项目方法名的对应
    static {
        codeAndMethodName = new HashMap((int) (103 / 0.75 + 1));

        codeAndMethodName.put("GD-1-1", "doFixityInformationDetection");
		……
        codeAndMethodName.put("GD-4-7", "doSysProcessSafety");

        codeAndMethodName.put("YJ-1-1", "doFixityInformationDetection");
    	……
        codeAndMethodName.put("YJ-4-7", "doSysProcessSafety");

        codeAndMethodName.put("BC-1-1", "doFixityInformationDetection");
       	……
        codeAndMethodName.put("BC-4-9", "doSaveEnvironment");
    }

    public static synchronized AbstractDetectionHandler getHandler() {
        if (allHandler != null) {
            return allHandler;
        }
        // 通过接口从IOC容器中获取对应的实现类
        DetectionService realDetectionService = SpringUtils.getBean(RealDetectionService.class);
        DetectionService completeDetectionService = SpringUtils.getBean(CompleteDetectionService.class);
        DetectionService availableDetectionService = SpringUtils.getBean(AvailableDetectionService.class);
        DetectionService safeDetectionService = SpringUtils.getBean(SafeDetectionService.class);
        if (realDetectionService == null) {
            throw new IllegalArgumentException("error: realDetectionService bean 注册失败！");
        }
        if (completeDetectionService == null) {
            throw new IllegalArgumentException("error: completeDetectionService bean 注册失败！");
        }
        if (availableDetectionService == null) {
            throw new IllegalArgumentException("error: availableDetectionService bean 注册失败！");
        }
        if (safeDetectionService == null) {
            throw new IllegalArgumentException("error: safeDetectionService bean 注册失败！");
        }
        allHandler = new AbstractDetectionHandler(null);
        AbstractDetectionHandler realHandler = new AbstractDetectionHandler(realDetectionService);
        AbstractDetectionHandler completeHandler = new AbstractDetectionHandler(completeDetectionService);
        AbstractDetectionHandler availableHandler = new AbstractDetectionHandler(availableDetectionService);
        AbstractDetectionHandler safeHandler = new AbstractDetectionHandler(safeDetectionService);
        allHandler.setNextHandler(realHandler);
        realHandler.setNextHandler(completeHandler);
        completeHandler.setNextHandler(availableHandler);
        availableHandler.setNextHandler(safeHandler);
        return allHandler;
    }
}

AbstractDetectionHandler 具体链的调用方法，其中 detectionService 在不同的 AbstractDetectionHandler 实例中赋予了不同的值：

public class AbstractDetectionHandler {
     // 责任链中的下一个元素
    protected AbstractDetectionHandler nextHandler;
    // detectionService是链中四个对象的父接口
    protected DetectionService detectionService;

    public void setNextHandler(AbstractDetectionHandler handler) {
        this.nextHandler = handler;
    }
   // 四性检测开始执行,使用责任链模式将任务串联起来，递归调用
    public DetectionBuilder detectionChain(DetectionBuilder detectionBuilder) {
        try {
            detectionBuilder = doDetection(detectionBuilder);
            if (nextHandler != null) {
                detectionBuilder = nextHandler.detectionChain(detectionBuilder);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return detectionBuilder;
    }
    //当前detectionBuilder需要执行的检测环节
    private DetectionBuilder doDetection(DetectionBuilder detectionBuilder) {
        DetectionSegmentType code = detectionBuilder.getDetection().getCode();
        if (code == null) {
            throw new IllegalArgumentException("参数缺失");
        }
        if (this.detectionService != null) {
            switch (code) {
                case 归档:
                    detectionBuilder = detectionService.doPostDetection(detectionBuilder);
                    break;
                case 移交:
                    detectionBuilder = detectionService.doMoveDetection(detectionBuilder);
                    break;
                case 长期保存:
                    detectionBuilder = detectionService.doSaveDetection(detectionBuilder);
                    break;
            }

        }
        return detectionBuilder;
    }
    public AbstractDetectionHandler(DetectionService detectionService) {
        this.detectionService = detectionService;
    }
}

AvailableDetectionServiceImpl 是 detectionService 的一个子类，在 AbstractDetectionHandler 类的 doDetection() 中调用，下面截取了类中的主要逻辑方法。

  • doPostDetection() 方法在 detectionService 的其他三个子类中都有实现，因为三个环节中都需要执行对应的四性检测。
  • doNeedDetection() 方法是为了实现按需执行检测项目（103个检测项不一定全部执行）。由于该方法使用的是反射调用类中的方法（即检测项目），故使用注解注入需要的实现类（涉及到 IOC 中循环注入可参考博主该文章）。
@Service
public class AvailableDetectionServiceImpl implements implements AvailableDetectionService {
	@Resource
    private RealDetectionService realDetectionService;
    @Resource
    private CompleteDetectionService completeDetectionService;
    @Resource
    private AvailableDetectionService availableDetectionService;
    @Resource
    private SafeDetectionService safeDetectionService;
    
    /**
     * 归档 可用性检测
     */
    @Override
    public DetectionBuilder doPostDetection(DetectionBuilder detectionBuilder) {
        doNeedDetection(fourDetection,detectionBuilder);
        return detectionBuilder;
    }
 	/**
     * 在环节和四性下检测需要的检测项目
     */
    public void doNeedDetection(String fourDetection, DetectionBuilder detectionBuilder) {
        //按拿到要检测的项目；反射调用对应的方法
        //通过文件的档案库id拿到检查项目,如果没有该级，则向上递归一级
        String orgId = detectionBuilder.getDetection().getArcfile().getOwnOrgId();
        String generalId = detectionBuilder.getDetection().getArcfile().getGeneralId();
        String repositoryId = detectionBuilder.getDetection().getArcfile().getRepositoryId();
        List<String> orgGeneralRepository = new ArrayList<>();
        if(StringUtils.isNotBlank(repositoryId)){
            orgGeneralRepository.add(repositoryId);
        }else if(StringUtils.isNotBlank(generalId)){
            orgGeneralRepository.add(generalId);
        }else {
            orgGeneralRepository.add(orgId);
        }

        DetectionSegmentType nowLinkType = detectionBuilder.getDetection().getCode();
        //将拿到该文件当前环节、当前四性下的检测项目
        List<FourDetection> fourDetectionList = fourDetectionServiceImpl.getFourDetectionByGeneralId(orgGeneralRepository, nowLinkType.getValue(), fourDetection);

        //遍历调用方法
        fourDetectionList.forEach(e -> {
            //判断该项目是否属于当前的环节
            if (e == null || !nowLinkType.getValue().equals(e.getLinkType())) {
                return;
            }
            DetectionService service = null;
            //自动注入的都将为成员变量在反射后，都将为null，故需要修改为从ioc中获取对应的对象
            DetectionClass detectionClass = (DetectionClass) EnumService.getEnum(DetectionClass.class, e.getFourDetection());
            switch (detectionClass) {
                case 真实性:
                    service = realDetectionService;
                    break;
                case 完整性:
                    service = completeDetectionService;
                    break;
                case 可用性:
                    service = availableDetectionService;
                    break;
                case 安全性:
                    service = safeDetectionService;
                    break;
            }
            if (service == null) {
                return;
            }
            Class<? extends DetectionService> aClass = service.getClass();
            try {
                String methodName = FourDetectionFactory.codeAndMethodName.get(e.getDetectionCode());//是否包含改方法的判断doElectronicDocumentsDetection
                Method test = aClass.getDeclaredMethod(methodName, DetectionBuilder.class);
                test.invoke(service, detectionBuilder);
            } catch (Exception a) {
                a.printStackTrace();
            }
        });
    }
}

责任链在 Spring MVC 的 HandlerExecutionChain 中的应用源码解析

在 Spring MVC 的 DispatcherServlet 类中，有如下的主要代码逻辑：
  doDispatch方法中，构建了 interceptor 执行链，将请求分配给 preHandle 执行，当 preHandle 方法返回为 false时，会调用到 afterCompletion 执行，最后调用 postHandle 方法。

protected void doDispatch (HttpServletRequest request, HttpServletResponse response) throws Exception {
            HandlerExecutionChain mappedHandler = null;
            mappedHandler = getHandler(processedRequest);
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
           //当上面的 applyPreHandle 返回false时，继续向下执行到
            mappedHandler.applyPostHandle(processedRequest, response, mv);
}


//调用拦截器的 interceptor.preHandle
boolean applyPreHandle (HttpServletRequest request, HttpServletResponse response) {
    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) {
                triggerAfterCompletion(request, response, null);
                return false;
            }
            this.interceptorIndex = i;*}
    }
    return true;
}
void triggerAfterCompletion (HttpServletRequest request, HttpServletResponse response,Exception ex){
     HandlerInterceptor interceptor = interceptors[i];
     try {
         interceptor.afterCompletion(request, response, this.handler, ex);
     }
 }
        
//调用拦截器的 interceptor.postHandle
void applyPostHandle (HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv){
    HandlerInterceptor interceptor = interceptors[i];
    interceptor.postHandle(request, response, this.handler, mv);
}
  • HandlerExecutionChain 本身不会执行 interceptor 的逻辑，只是将请求分配给 chain 上注册的 interceptor 执行；
  • HandlerExecutionChain 维护了 HandlerInterceptor 的集合。

监听器（listener）、过滤器（filter）、拦截器（interceptor）的执行顺序参考
SpingMvc的整体执行流程参考

BigBug_500
关注
专栏目录
Spring MVC 的责任链模式
学无止境
10-31 653
Spring MVC 框架使用了责任链模式来处理HTTP请求的流程。这个责任链模式主要包括多个拦截器（Interceptor）以及处理器（Handler），它们协同工作以完成请求的处理和响应。责任链模式的好处是，它允许你将请求处理过程划分为多个独立的拦截器和处理器，每个拦截器或处理器负责不同的任务，使代码更加模块化和可扩展。这种模式允许你轻松地添加、删除或修改拦截器，以满足不同的需求，如安全性、日志记录、性能优化等。
Spring MVC中的建造者模式
class_class957的博客
09-25 58
建造者模式在Spring MVC中常被用于构建复杂的请求对象，通过将构建过程与对象的表示分离，使得同样的构建过程可以创建不同的表示。通过配置XML文件或注解，我们可以定义SQL语句和结果集与Java对象之间的映射关系，MyBatis会在运行时动态地生成相应的Java代码，从而实现了数据库操作与Java对象之间的转换。建造者模式是一种创建对象的设计模式，它可以将对象的构建过程与其表示分离，从而使得同样的构建过程可以创建不同的表示。首先，我们需要定义一个数据表对应的Java对象，例如一个。
浅谈springMVC中的设计模式(1)——责任链模式
ljw761123096的博客
03-17 1万+
最近终于闲了下来，准备自己记录些东西。网上关于springMVC的资料很多，但关于设计模式的还有限，我就想把springMVC源码中的设计模式抽出来做成一个系列，简单的谈一下其中的实现原理，作为一种学习分享，以后有更深的感悟也会更新。 先从一张图对整个springMVC的运作流程有一个大致的了解，图片侵删。 HandlerExecutionChain 其中我们可以看到，在springMV...
Spring中如何使用责任链模式
weixin_33910460的博客
05-29 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringMVC中的责任链模式详解
qq_35876365的博客
03-28 575
本文以SpringMVC源码为依据来学习设计模式之责任链模式在框架中的落地。
责任链模式-以SpringMVC中DispatcherServlet的HandlerExecutionChain为例
shining的专栏
04-12 462
责任链模式的定义： 责任链模式为请求创建了一个接收者对象的链，在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。 在SpringMVC中DispatcherServlet的HandlerExecutionChain也应用了这一设计模式的思路(可能并不是太典型，这个最后总结)： protected void doD...
Spring MVC中的建造者模式——简化后端开发
class_class957的博客
09-23 81
在Spring MVC中，我们可以将复杂的POJO对象的构建过程封装在建造者类中，从而简化对象的创建过程。使用建造者模式可以将这些复杂的构造方法封装在一个独立的建造者类中，从而简化POJO的创建过程。建造者模式的核心思想是将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。使用建造者模式可以将对象的构建过程封装在一个独立的建造者类中，从而使得代码更加清晰、可读，并且方便扩展。通过将对象的构建逻辑封装在建造者类中，我们可以在不修改原有代码的情况下，方便地引入新的属性或构建逻辑。
Spring Web MVC (Spring MVC) 的相关例题及解析
热门推荐
努力是为了站在万人之中，成为别人的光
03-11 3万+
MVC、web MVC、Spring MVC 和 Spring Web MVC的联系与区别： 1.MVC 是一种架构分层模式 2.web MVC 是指在 web 领域下实践的 MVC，因为 web 领域的视图层跟 native 应用的视图层不太能划等号 3.Spring MVC 和 Spring Web MVC 是同一个东西，就是 Spring Framework 里的一个模块。在 Spring Framework 介绍页面 写的是 Spring MVC，然而点进去后具体的描述页面 使用 Spring We
spring mvc
04-18
1. **模型（Model）**：在 Spring MVC 中，模型通常由业务对象（BO）或数据访问对象（DAO）组成，它们负责处理应用的数据逻辑。模型对象与视图和控制器分离，可以独立维护和更新。 2. **视图（View）**：视图是用户...
外文翻译Spring的MVC构架模式-CSDN下载.2018_03_16
03-16
在 Spring MVC 中，模型通常由 Java 对象（称为 POJOs）组成，它们封装了应用程序的数据和行为。Spring 提供了 IoC 容器来管理和实例化这些对象，使得开发者可以方便地注入依赖，实现松耦合。 2. **视图（View）** ...
SpringAOP之探秘（动态代理、责任链模式、注解使用）
12-14
SpringAOP之探秘（动态代理、责任链模式、注解使用）- 详情：https://blog.csdn.net/Dream_Weave/article/details/85008674
责任链模式例子
10-17
在《Head First Design Patterns》文中是这么介绍责任链模式的，“通过责任链模式，你可以为某个请求创建一个对象链。每个对象依次检查此请求，并对其进行处理，或者将它传给链中的下一个对象”,这句话已经很好了解了。责任链模式属于行为型模式。
责任链模式与spring容器的搭配应用
kfashfasf的博客
02-23 1125
有个需求，原先只涉及到一种A情况设备的筛选，每次筛选会经过多个流程，比如先a功能，a功能通过再筛选b功能，然后再筛选c功能，以此类推。现在新增了另外一种B情况的筛选，B情况同样需要A情况的筛选流程，并且需要在A情况的基础上，新增另外的功能筛选，这里假设A需要a、b、c功能的筛选，而B需要a、b、c、d功能的筛选，并且这些功能的筛选的顺序可能发生变动，比如新增了某个筛选，这个筛选涉及到的计算量少那肯定可以把这个置在前面先处理，不满足条件就return，咋一看，这个需求很符合责任链模式的应用场景，下面介绍编码。
java：责任链设计模式配合Spring@Order注解使用场景
a232884c的博客
01-10 1808
java的责任链模式，经典使用的场景为SpringMVC的doDispatch下，针对请求的过滤链式行为。实际开发场景中，可配合Spring的@Order注解，定义1个有顺序的链式Components列表，根据Components列表的顺序依次处理，如果中途存在处理失败的Component，则终止（或过滤，依赖实际场景即可）整个处理过程，实际使用方式见如下。
Spring中使用责任链设计模式
爱钻研的小张
08-23 928
在责任链模式中，通常会创建一个抽象处理器类，其中包含一个指向下一个处理器的引用。具体的处理器类继承自抽象处理器类，并实现自己的处理逻辑。当收到请求时，首先由第一个处理器处理，如果该处理器无法处理，则将请求传递给下一个处理器，依次类推，直到找到可以处理请求的处理器为止。过滤器链：在Web开发中，可以使用责任链模式来处理过滤器链。AOP切面链：在Spring框架的AOP（面向切面编程）中，可以使用责任链模式来实现切面的执行链。配置解析链：在Spring框架中，可以使用责任链模式来解析复杂的配置信息。
设计模式（五）责任链模式——在Spring中使用责任链模式
lishuzhen5678的博客
07-06 5349
前言 在 设计模式（四）责任链模式 —— 责任链模式结构 中分析了责任链模式的结构，在...
Spring设计模式-实战篇之责任链模式
最新发布
qq_53281187的博客
03-25 1772
解耦合：你无需关注你的下一个链条是如何实现的，只需要把自己的模块实现好即可，并且链条之间的顺序可以随意切换，在构建责任链时指定Next即可，无需去各个实现类中进行修改代码；当需要新增加或者修改支付回调处理的步骤时，可以通过添加新的处理器来实现，而无需修改已有的代码。每一个步骤的实现代码都在独立的类中实现，这样可以更容易地理解和调试代码，不像很多业务代码一样，一大堆业务处理逻辑放在一个方法里面调来调去，很容易搞迷糊。
责任链模式（springMvc放行资源实例）
weixin_49161209的博客
08-28 313
责任链模式 一、责任链模式 1、定义： 就是当http发送的请求有多个处理者的时候，（一般会挨个去找每个处理者看能不能处理，如果不能处理就找下一个处理者处理，一直到找到，如果没有最后都没找到就抛出异常），这时为了避免请求者和多个处理者的高度耦合，将所有的处理者练成一条线，每个处理者都会有下一个处理者的引用，这样就能连成一条线 2、优点： 降低了请求端与处理端对象的高度度耦合 主要是请求端只需要将请求发送过来，可以不管处理端是怎样处理 处理端能得到更好的扩展 主要是处理端全部实现同一接口（该
【设计模式系列12】责任链模式原理和示例及其在Spring源码中的运用
zwx900102的博客
09-07 7036
责任链模式分析前言什么是责任链模式写法示例登录用户信息类Handler抽象类链路节点Handler实现类校验账号密码Handler校验角色Handler校验权限Handler测试运行结果和传统写法对比责任链模式结合建造者模式改写Handler抽象类测试运行结果责任链模式角色责任链模式适用场景责任链模式源码中体现责任链模式优缺点优点缺点总结 前言 上一篇，我们介绍了建造者模式，以及建造者模式在源码中的运用，今天我们会先介绍一下责任链模式，然后会再通过一个示例来将责任链模式和建造者模式结合起来应用。 什么是责任
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值