【代码设计】链表结构解决多流程校验

已于 2022-05-25 17:17:31 修改
阅读量252 收藏
点赞数
分类专栏： Android 文章标签： 链表 java 数据结构 android
于 2022-05-19 17:28:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YoungOne2333/article/details/124867817
版权

目的

使用合理的代码设计，解决业务场景的中的实际问题。

背景介绍

在实际的业务场景中，用户的一个操作行为，是否允许真正被执行，往往会涉及到多流程的校验，一旦有条件不满足将会被中止。以下面流程图为例： 条件结构流程图.png 用户点击了打赏按钮，会进行是否有网络检查，没有网络，会有网络连接弹框，等待用户连接结果（涉及异步回调），如果没有连接，不继续下面流程直接结束；如果连接了，会进行是否登录判断，没有登录，则调用引导登录（涉及异步回调），等待登录结果，如果失败，则不继续下面的流程，成功则进行是否是成人账号判断（涉及异步回调），不是则直接结束，是成人账号则真正开始打赏。

根据流程写的代码

package com.example.quickdemo.node.before;

public class Test {
   public static void main(String[] args) {
      onClickTip();
   }

   /**
    * 点击打赏按钮
    */
   private static void onClickTip() {
      if (!NetworkHelper.getInstance().isConnect()) {
         System.out.println("网络未连接");
         NetworkHelper.getInstance().requestConnectNetwork(new NetworkHelper.NetworkCallback() {
            @Override
            public void onResult(boolean result) {
               if (result) {
                  System.out.println("网络连接成功");
                  if (!LoginHelper.getInstance().isLogin()) {
                     System.out.println("用户未登录");
                     LoginHelper.getInstance().requestLogin(new LoginHelper.LoginCallback() {
                        @Override
                        public void onResult(boolean success) {
                           if (success) {
                              System.out.println("用户登录成功");
                              AccountHelper.getInstance().checkAccountType(new AccountInfo(),
                                 new AccountHelper.AccountCallback() {
                                    @Override
                                    public void onResult(int type) {
                                       if (type == AccountHelper.ACCOUNT_TYPE_ADULT) {
                                          System.out.println("是成人帐号");
                                          doTip();
                                       } else {
                                          System.out.println("不是成人帐号");
                                       }
                                    }
                                 });
                           } else {
                              System.out.println("用户登录失败，结束流程");
                           }
                        }
                     });
                  }
               }
            }
         });
      }
   }

   /**
    * 进行打赏
    */
   public static void doTip() {
      System.out.println("通过了一系列合法性校验，可以进行打赏");
   }
}

会明显的发现，代码实现上陷入了回调地狱，即在回调中右进行了不断的回调，直接表现在会出现多层的代码缩进，回调地狱往往会使代码的易读性大大的降低，各个校验的耦合性大大增强。

下面是各个网络、登录，账号校验的实现代码，仅仅辅助示例说明，并不是真正的连接网络，进行登录，帐号校验的实现

package com.example.quickdemo.node.before;

/**
 * 网络辅助类
 */
public class NetworkHelper {
   private boolean connect;

   private static final NetworkHelper INSTANCE = new NetworkHelper();

   private NetworkHelper() {
   }

   public static NetworkHelper getInstance() {
      return INSTANCE;
   }

   public boolean isConnect() {
      return connect;
   }

   public void setConnect(boolean connect) {
      this.connect = connect;
   }

   public void requestConnectNetwork(final NetworkCallback callback) {
      new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               Thread.sleep(500);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            connect = true;
            if (callback != null) {
               callback.onResult(connect);
            }
         }
      }).start();
   }

   interface NetworkCallback {
      void onResult(boolean result);
   }
} 

package com.example.quickdemo.node.before;

/**
 * 登录辅助类
 */
public class LoginHelper {
   private boolean isLogin;


   private static final LoginHelper INSTANCE = new LoginHelper();

   private LoginHelper() {
   }

   public static LoginHelper getInstance() {
      return INSTANCE;
   }

   public boolean isLogin() {
      return isLogin;
   }

   public void requestLogin(final LoginCallback callback) {
      new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               Thread.sleep(500);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            isLogin = true;
            if (callback != null) {
               callback.onResult(isLogin);
            }
         }
      }).start();
   }


   interface LoginCallback {
      void onResult(boolean success);
   }
} 

package com.example.quickdemo.node.before;

/**
 * 帐号辅助类
 */
public class AccountHelper {
   public static final int ACCOUNT_TYPE_ADULT = 1;

   private static final AccountHelper INSTANCE = new AccountHelper();

   private AccountHelper() {
   }

   public static AccountHelper getInstance() {
      return INSTANCE;
   }

   public void checkAccountType(AccountInfo accountInfo, final AccountCallback callback) {
      new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               Thread.sleep(500);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            if (callback != null) {
               callback.onResult(ACCOUNT_TYPE_ADULT);
            }
         }
      }).start();
   }

   interface AccountCallback {
      void onResult(int type);
   }
}

使用链表结构解决回调地狱

每一种校验可以看做是链表的一个节点，进行当前节点的校验时，如果校验不成功则不继续进行，如果校验成功，则判断是否有下一个节点，如果有则执行下一个节点。

在开始执行链表的逻辑之前，首先需要构建出一个链表，而链表节点的先后顺序就是多流程校验各流程的顺序。

首先定义结点

package com.example.quickdemo.node.after;

public abstract class FlowNode {
    private FlowNode next;

    /**
     * 事务处理
     */
    public abstract void process();

    public FlowNode getNext() {
        return next;
    }

    public void setNext(FlowNode next) {
        this.next = next;
    }
}

创建网络、登录，账号校验各自的结点实现

package com.example.quickdemo.node.after;

import com.example.quickdemo.node.before.NetworkHelper;

/**
 * 网络结点
 */
public class NetworkFlowNode extends FlowNode{
    @Override
    public void process() {
        if (NetworkHelper.getInstance().isConnect()) {
            System.out.println("网络已连接");
            FlowNode next = getNext();
            if (next != null) {
                next.process();
            }
        } else {
            System.out.println("网络未连接");
            NetworkHelper.getInstance().requestConnectNetwork(new NetworkHelper.NetworkCallback() {
                @Override
                public void onResult(boolean result) {
                    if (result) {
                        System.out.println("网络连接成功");
                        FlowNode next = getNext();
                        if (next != null) {
                            next.process();
                        }
                    } else {
                        System.out.println("用户登录失败，结束流程");
                    }
                }
            });
        }
    }
} 

package com.example.quickdemo.node.after;

import com.example.quickdemo.node.before.LoginHelper;

/**
 * 登录结点
 */
public class LoginFlowNode extends FlowNode{
    @Override
    public void process() {
        if (LoginHelper.getInstance().isLogin()) {
            System.out.println("用户已登录");
            FlowNode next = getNext();
            if (next != null) {
                next.process();
            }
        } else {
            System.out.println("用户未登录");
            LoginHelper.getInstance().requestLogin(new LoginHelper.LoginCallback() {
                @Override
                public void onResult(boolean success) {
                    if (success) {
                        System.out.println("用户登录成功");
                        FlowNode next = getNext();
                        if (next != null) {
                            next.process();
                        }
                    } else {
                        System.out.println("用户登录失败，结束流程");
                    }
                }
            });
        }
    }
} 

package com.example.quickdemo.node.after;

import com.example.quickdemo.node.before.AccountHelper;
import com.example.quickdemo.node.before.AccountInfo;

/**
 * 账号校验结点
 */
public class AdultAccountFlowNode extends FlowNode {
    @Override
    public void process() {
        AccountHelper.getInstance().checkAccountType(new AccountInfo(), new AccountHelper.AccountCallback() {
            @Override
            public void onResult(int type) {
                if (type == AccountHelper.ACCOUNT_TYPE_ADULT) {
                    System.out.println("是成人帐号");
                    FlowNode next = getNext();
                    if (next != null) {
                        next.process();
                    }
                } else {
                    System.out.println("不是成人帐号,结束流程");
                }
            }
        });
    }
}

打赏服务，进行打赏业务时，进行了链表的构建，类似于搭积木，各个校验模块之间已经没有直接的耦合关系。

package com.example.quickdemo.node.after;

/**
 * 打赏服务
 */
public class TipService extends FlowNode{

    public void onClickTip() {
        // 构建校验链表
        // (1) 创建结点
        NetworkFlowNode networkFlowNode = new NetworkFlowNode();
        LoginFlowNode loginFlowNode = new LoginFlowNode();
        AdultAccountFlowNode adultAccountFlowNode = new AdultAccountFlowNode();
        // (2)根据校验顺序连接结点
        networkFlowNode.setNext(loginFlowNode);
        loginFlowNode.setNext(adultAccountFlowNode);
        adultAccountFlowNode.setNext(this);

        // 触发链表调用
        networkFlowNode.process();
    }

    @Override
    public void process() {
        doTip();
    }

    /**
     * 进行打赏
     */
    public void doTip() {
        System.out.println("通过了一系列合法性校验，可以进行打赏");
    }
}

调用测试

package com.example.quickdemo.node.after;

public class Test {
    public static void main(String[] args) {
        new TipService().onClickTip();
    }
}

输出

网络未连接
网络连接成功
用户未登录
用户登录成功
是成人帐号
通过了一系列合法性校验，可以进行打赏

如果进行登录引导时，用户不进行登录直接返回，即引导登录流程返回失败，输出将是：

网络未连接
网络连接成功
用户未登录
用户登录失败，结束流程

总结

针对具体的业务场景，设计出相适应的代码设计，才能够更好的演进。本文介绍的方案其实和设计模式中的责任链模式比较类似，责任链本质也是一个链表，只是其处理大致逻辑是，当前结点如果能够处理请求，则直接处理，然后结束，如果不能够处理，则交给下一个结点处理。

在一些框架中，如RxJava，Kotlin的协程，前端的Promise都是可以用来解决多流程校验，存在回调地狱的场景。提到的框架没有仔细深入的了解过，不敢讲太多～

文末

我总结了一些Android核心知识点，以及一些最新的大厂面试题、知识脑图和视频资料解析。

需要的小伙伴直接点击文末小卡片免费领取哦，以后的路也希望我们能一起走下去。（谢谢大家一直以来的支持，需要的自己领取）

Android学习PDF+架构视频+面试文档+源码笔记

部分资料一览：

  • 330页PDF Android学习核心笔记（内含8大板块）

  • Android学习的系统对应视频

  • Android进阶的系统对应学习资料

  • Android BAT大厂面试题（有解析）

领取地址：

在这里插入图片描述

嘴巴吃糖了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于校验器链的简单实现，支持对象按照属性来自定义校验，可以重用校验器。
09-04
基于校验器链的简单实现，支持对象按照属性来自定义校验，可以重用校验器。测试代码请看test.jy.Test类。
数据结构之链表OJ练习检验你的链表水平是否合格
qq_56999918的博客
11-24 1105
1.反转链表 对应letecode链接： https://leetcode-cn.com/problems/UHnkqh/ 解题分析： 方法1，双指针法: 设置两个链表：ans 表示已经被反转的链表, head 表示还未被反转的链表。 遍历链表，每次将未被反转的链表 head 的 首元节点反转，直至未被反转的链表为空。 对应代码： class Solution { public: ListNode* reverseList(ListNode* head) { .
【设计模式】责任链的基本概念及使用Predicate灵活构造校验链
最新发布
积木成林，聚沙成塔
08-08 856
在最近的开发中遇到了这么一个需求，需要对业务流程中的各个参数做前置校验，校验通过才能执行后续的流程。经过一番需求分析后发现，有大量的业务入口需要做的校验是相同的，同时在业务迭代的过程中涉及到的校验规则也会有所增减。所以就必须考虑到代码的复用性和拓展性，决定使用责任链模式来剥离变化。本篇先简单的讲解了责任链模式的概念，通过一个简单的注册用户需求代入了责任链的实现方式，并提出了用责任链是实现校验时灵活的地方。然后针对这种不灵活，通过Java8中的Predicate。
基于apache-commons-chain做校验链
dengjili的专栏
03-23 1047
方案 我们将我们的检验抽象成单独的节点，串成一条链来做校验 这里，我将采用基于数据库配置方案来封装基本框架，建立三张表来建立关系 建立一种场景 SELECT * FROM rule.rm_sence; 根据场景code，找出校验链 SELECT t1.* FROM rule.rm_rule t1, rule.rm_rule_sence_rel t2, rule.rm_sence t3 ...
java 多文件校验_编写校验规则文件
weixin_42551028的博客
02-13 312
Struts 2提供了基于验证框架的输入校验，在这种校验方式下，所有的输入校验只需要编写简单的配置文件，Struts 2的验证框架将会负责进行服务器校验和客户端校验。下面应用将会示范如何利用Struts 2的校验框架进行输入校验。使用Struts 2的校验框架进行校验无须对程序代码进行任何改变，只需编写校验规则文件即可，校验规则文件指定每个表单域应该满足怎样的规则。本应用所使用的表单代码如下。程序...
DES.rar_visual c_数据结构课设
09-22
标题中的"DES.rar_visual c_数据结构课设"揭示了本次知识分享的主要内容：一个基于Visual C++编译环境的数据结构课程设计项目，该项目实现了DES（Data Encryption Standard）算法，这是一种经典的对称加密方法。...
软件设计师课程体系结构
04-20
- **算法描述**（流程图、伪代码、决策表）。 - **算法的复杂性**。 #### 二、计算机系统知识 **第二章：计算机系统知识** ##### 学习目的 通过本章节的学习，掌握计算机的硬件、软件、网络、数据库、多媒体、...
c++课程设计宾馆客房管理系统.zip
09-15
在本项目中，学生需要设计并实现一个能够管理宾馆客房预订、入住、退房等业务流程的系统。 在C++中，开发这样的系统通常涉及到以下几个核心知识点： 1. **面向对象编程**：C++是支持面向对象编程的语言，系统中的...
ldpc编译码c代码
12-04
在C语言中实现LDPC编译码涉及到多个关键知识点，包括编码原理、数据结构以及编程实践。** **1. LDPC编码原理：** - **线性分组码**：LDPC码属于线性分组码，它通过在信息位上添加校验位来形成码字，码字中的所有位...
2005-2009软件设计师历年真题
05-18
　• 系统详细设计（代码设计、数据库设计、用户界面设计、处理过程设计） 　• 系统设计说明书 　3.4 系统实施知识 　• 系统实施的主要任务 　• 结构化程序设计、面向对象程序设计、可视化程序设计 　• 程序设计...
Observe变种，校验链
seablue_xj的专栏
08-10 806
近期，由于项目需要，需要重新设计一套系统的拦截机制，其场景如下： 1.首先，系统需要对发起的请求做是否需要拦截过过滤，如果不需要拦截，则放过，进行第二层拦截 2.对于系统的角色的所属权限进行校验，如果为角色默认权限则放过，如果非角色默认可使用权限，则交由第三层用户权限进行控制
编码技巧——校验器（职责链+抽象模版）
娜娜米的博客
05-09 963
日常开发中可能遇到这样的业务场景：请求从入口进来，需要经过层层的校验，通过校验后才会执行业务操作（写操作、RPC、异步消息...）；这里前置的多层校验流程中，从类型上看，部分是基本参数校验，部分是包含业务逻辑的校验，并且部分校验是可以并行，部分是有依赖关系的；此外，从代码的通用性来说，对于流程相对固定的业务逻辑，完全可以提前定义好多个校验器，通过配置，可动态的拔插这些预制的校验器以及其顺序；本篇介绍用户下单前业务订单多层校验场景的代码示例；
如何优雅地组织校验代码
weixin_42590838的博客
10-11 138
validator
责任链模式的高级用法：多级校验、工作流，这样写代码才足够优雅！
码猿技术专栏
12-26 200
大家好，我是不才陈某~责任链模式，简而言之，就是将多个操作组装成一条链路进行处理。请求在链路上传递，链路上的每一个节点就是一个处理器，每个处理器都可以对请求进行处理，或者传递给链路上的下一个处理器处理。‍‍应用场景责任链模式的应用场景，在实际工作中，通常有如下两种应用场景。操作需要经过一系列的校验，通过校验后才执行某些操作。工作流。企业中通常会制定很多工作流程，一级一级的去处理任务。下面通过两个案...
[设计模式] 责任链模式校验下单参数
OxYGC
10-24 405
顶层抽象类必要非空参数校验必要非空参数校验测试类。
多重校验神器责任链模式
a779868946的博客
09-24 705
背景 最近在做需求，写一个方法，先在前面做验证，if不满足A条件则return，if不满足B条件则return…一共写了5个验证，等验证通过以后才执行下面的逻辑，这个也没问题。过了一阵产品提了需求，跟这个方法类似，我又把这个方法copy了一份，只不过验证条件稍微有点不一样，要变成6个验证了。 这时候我就发现有三个问题，第一重复代码，相同的A条件B条件C条件写了两份，没有复用。第二，“头重脚轻”，比如100行的方法，前面60行都是验证，后面40行才是真正有用的业务代码，你看一个方法功能的时候前面验证肯定是不关
审核类数据库结构分享
TROUBLE I AM IN
11-06 3001
一个审核类的数据表结构分享。
C语言实现数据结构链表操作示例
"这份资源是关于C语言实现数据结构中链表操作的通用范例源代码，包括了头插法建立单链表和限制链表长度建立长单链表的示例。" 在计算机科学中，链表是一种基础的数据结构，它由一系列节点（也称为元素或记录）组成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值