Easytool 文档

最新推荐文章于 2024-05-10 09:14:14 发布
最新推荐文章于 2024-05-10 09:14:14 发布
阅读量1k 收藏 22
点赞数 23
分类专栏： Java 文章标签： 任务编排 java 通用工具 easytool
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43659871/article/details/135125352
版权

Easytool

Easytool 的目标是干掉大部分冗余的复杂代码，从而最大限度的避免“复制粘贴”代码的问题，使我们能去更专注业务，提升我们的代码质量。

简介

Easytool 是一个小型的Java工具类库，封装了一些常用的通用的方法，降低了相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅。

Easytool 中的大部分方法来自开发过程中的真实需求，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当。
完整代码地址：https://github.com/Jinhx128/easytool

模块

名称介绍
easytool-all包含所有模块的引用
easytool-core核心包，包括对集合处理、日期、各类Util等
easytool-crypto加密解密模块，提供对称、非对称和摘要算法封装
easytool-process基于spring封装的任务编排轻量级框架

1. easytool-core

1.1 待完善…

2. easytool-crypto

2.1 待完善…

3. easytool-process

easytool-process是一个基于spring封装的任务编排轻量级框架

由来
  • 起初是因为自己在开发过程中遇到比较复杂的业务场景，还伴随着并发操作，就抽象了一层方法方便自己在项目中使用。
  • 后面在其他项目也遇到类似的场景，此时就想抽象出来公共的东西，方便在其他项目能快速接入，这样可以干掉大部分重复的冗余代码，同时也降低了出错的可能性。
使用场景
  • 比较复杂的业务场景，比如订单详情，需要聚合大量的数据，而且根据订单状态的变化，需要的数据也有所变化。
3.1 组成

主要包含：上下文，节点，链路，其他组件

image.png

3.1.1 上下文
  1. 所有节点之间的数据交互都通过上下文进行传递
  2. 上下文包含了整个链路执行过程中所需要用到的数据，包括入参，中间数据，出参等字段。
  3. 只需要创建一个类，把所需要用到的字段加入进去即可，命名一般是链路名+Context后缀。
3.1.2 节点

一个节点代表一个任务，节点通过编排组成链路。创建节点需要继承AbstractNode抽象类，并实现相关抽象方法，由于依赖spring，所以需要加@Component注解。

image.png

详解
名称说明
getDependsOnNodes()抽象方法，返回当前节点依赖的前置节点集合，必须实现。通过该方法进行链路任务编排，注意：只需要返回直接前置节点，比如链路为A->B->C，此时C节点只需要返回B节点即可，另外如果无依赖的节点，比如A节点，此时返回空或空集合即可
isSkip(ChainContext chainContext)抽象方法，用于跳过当前节点，必须实现。返回ture则跳过，false则不跳过，比如某种状态下不需要执行当前节点的场景
execute(ChainContext chainContext)抽象方法，用于编写当前节点的逻辑，必须实现。重点在此通过上下文chainContext与其他节点进行数据传递，会按照链路编排的顺序执行各个节点，最终获取相应的数据/操作
businessFail(String msg)/businessFail(int code, String msg)内置方法，当遇到业务异常时，比如某个数据不存在，此时可以直接中断整个链路，返回业务错误提示，需要用到时调用即可
onBusinessFail(ChainContext chainContext, BusinessException e)抽象方法，是一个回调方法，必须实现。需要搭配businessFail方法使用，当执行了上述方法后会执行
onUnknowFail(ChainContext chainContext, Exception e)抽象方法，是一个回调方法，必须实现。当节点执行遇到未知错误时会执行
onTimeoutFail(ChainContext chainContext)抽象方法，是一个回调方法，必须实现。当节点执行遇到超时错误时会执行
onSuccess(@NonNull ChainContext chainContext)内置方法，是一个回调方法，当节点执行成功时会执行，需要用到时重写即可
afterExecute(@NonNull ChainContext chainContext)内置方法，是一个回调方法，当节点执行遇到完成时会执行。注意，是执行完成，就是无论有没有出现异常，需要用到时重写即可
3.1.3 链路

一个链路包含了多个已经按照顺序编排好的节点，创建链路需要继承AbstractChain抽象类，并实现相关抽象方法，由于依赖spring，所以需要加@Component注解。

image.png

详解
名称说明
getChainTimeout()内置方法，返回的是该链路的超时时间，执行超过该时间则中断链路并返回超时异常结果，默认值是200ms，需要替换时重写即可
getThreadPool()内置方法，返回的是执行该链路的线程池，内置默认线程池，需要替换时重写即可
execute(ChainContext chainContext)抽象方法，用于编写当前节点的逻辑，必须实现。重点在此通过上下文chainContext与其他节点进行数据传递，会按照链路编排的顺序执行各个节点，最终获取相应的数据/操作
KeyThreadContextConfig/SingletonThreadContextConfig内置类，用于配置线程上下文信息，包含新增，获取，删除三个动作
getThreadContextInitConfigs()内置方法，返回的是用于配置线程上下文信息集合，也就是4中的两种，一种需要key，一种不需要。最常见的场景就是用于链路追踪的traceId，需要用到时重写即可。
checkParams(ChainContext chainContext)抽象方法，用于在执行链路之前做参数校验使用，必须实现
businessFail(String msg)/businessFail(int code, String msg)内置方法，当遇到业务异常时，比如某个数据不存在，此时可以直接中断整个链路，返回业务错误提示，需要用到时调用即可行
onBusinessFail(ChainContext chainContext, BusinessException e)抽象方法，是一个回调方法，必须实现。需要搭配businessFail方法使用，当执行了上述方法后会执行
onUnknowFail(ChainContext chainContext, Exception e)抽象方法，是一个回调方法，必须实现。当链路执行遇到未知错误时会执行
onTimeoutFail(ChainContext chainContext)抽象方法，是一个回调方法，必须实现。当链路执行遇到超时错误时会执行
onSuccess(@NonNull ChainContext chainContext)内置方法，是一个回调方法，当链路执行成功时会执行，需要用到时重写即可
afterExecute(@NonNull ChainContext chainContext)内置方法，是一个回调方法，当链路执行遇到完成时会执行。注意，是执行完成，就是无论有没有出现异常，需要用到时重写即可
openMonitor()内置方法，用于开启链路监控，会记录并定时打印链路及各节点执行的耗时等信息。返回ture则开启，false则不开启，需要用到时重写即可
setNodeInfo()抽象方法，用于添加链路节点，必须实现。内部通过下面方法添加节点，注意：链路的执行顺序跟此处的添加顺序无关
addInterruptNode/addInterruptNodes内置方法，增加一个中断节点。执行遇到异常时中断链路，并返回异常信息。参数：节点类，获取节点超时时间方法
addAbandonNode/addAbandonNodes内置方法，增加一个抛弃节点。执行遇到异常时抛弃该节点，继续执行后续节点。参数：节点类，获取节点超时时间方法
addRetryNode/addRetryNodes内置方法，增加一个重试节点。执行遇到异常时重试执行该节点，达到最大重试次数后还未执行成功，则中断链路，并返回异常信息。参数：节点类，获取节点超时时间方法，重试次数
3.1.4 其他组件
  1. ChainContext：链路上下文，用于创建统一的上下文，该上下文还包含了其他信息，我们只需要关心内部的contextInfo即可，也就是操作chainContext.getContextInfo()。
  2. ChainHandler：链路执行器，用于执行指定链路，并可指定需要返回的数据。
  3. Monitor：监控器，开启后会记录并定时打印链路及各节点执行的耗时等信息。
  4. 查看日志：需要注意链路内部打印的日志级别为info！可以通过getThreadContextInitConfigs()内置方法设置链路id，然后通过下面的命令查询
## 会有整个执行过程的细节日志
grep '链路id' xx.log

## 会有整个链路过程的细节日志，过滤一些可能无关的日志
grep '链路id' xx.log | grep 'process'

## 会有整个链路过程的细节日志，包括一些错误日志（错误栈信息可能换行）
grep -A 50 '链路id' xx.log | grep 'process'
3.2 简单讲一下Demo

image.png

第一步，在pom.xml加入依赖，如下
<dependency>
    <groupId>cc.jinhx</groupId>
    <artifactId>easytool-all</artifactId>
    <version>自行查看最新版本</version>
</dependency>

可以根据需求对每个模块单独引入，也可以通过引入easytool-all方式引入所有模块。

第二步，创建上下文，如下

DemoContext

import lombok.Data;

/**
 * DemoContext
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Data
public class DemoContext {

    // ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 入参 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

    // ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 入参 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

    private String req;

    // ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 中间数据 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

    private String dataA;

    private String dataB;

    private String dataC;

    // ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 中间数据 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑


    // ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 结果 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

    private String dataD;

    private String dataE;

    private String dataF;

    private String dataG;

    // ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 结果 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

}
第三步，创建多个节点，DemoGetDataANode，DemoGetDataBNode，DemoGetDataCNode，DemoGetDataDNode，DemoGetDataENode，DemoGetDataFNode，DemoGetDataGNode，如下

DemoGetDataANode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Set;

/**
 * DemoGetDataANode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataANode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return null;
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("req".equals(demoContextInfo.getReq())){
            demoContextInfo.setDataA(demoService.getDataA());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataBNode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataBNode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataBNode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Collections.singletonList(DemoGetDataANode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataA".equals(demoContextInfo.getDataA())){
            demoContextInfo.setDataB(demoService.getDataB());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataCNode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataBNode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataCNode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Collections.singletonList(DemoGetDataANode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataA".equals(demoContextInfo.getDataA())){
            demoContextInfo.setDataC(demoService.getDataC());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataDNode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataDNode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataDNode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Collections.singletonList(DemoGetDataANode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataA".equals(demoContextInfo.getDataA())){
            demoContextInfo.setDataD(demoService.getDataD());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataENode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataENode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataENode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Arrays.asList(DemoGetDataBNode.class, DemoGetDataCNode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataB".equals(demoContextInfo.getDataB()) && "dataC".equals(demoContextInfo.getDataC())){
            demoContextInfo.setDataE(demoService.getDataE());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataFNode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataENode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataFNode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Collections.singletonList(DemoGetDataCNode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataC".equals(demoContextInfo.getDataC())){
            demoContextInfo.setDataF(demoService.getDataF());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}

DemoGetDataGNode

import cc.jinhx.easytool.process.BusinessException;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.service.DemoService;
import cc.jinhx.easytool.process.node.AbstractNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * DemoGetDataENode
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Component
public class DemoGetDataGNode extends AbstractNode<DemoContext> {

    @Autowired
    private DemoService demoService;

    @Override
    public Set<Class<? extends AbstractNode>> getDependsOnNodes() {
        return new HashSet<>(Collections.singletonList(DemoGetDataENode.class));
    }

    @Override
    protected boolean isSkip(ChainContext<DemoContext> chainContext) {
        return false;
    }

    @Override
    protected void execute(ChainContext<DemoContext> chainContext) {
        DemoContext demoContextInfo = chainContext.getContextInfo();
        if ("dataE".equals(demoContextInfo.getDataE())){
            demoContextInfo.setDataG(demoService.getDataG());
        }
    }

    @Override
    public void onUnknowFail(ChainContext<DemoContext> chainContext, Exception e) {

    }

    @Override
    public void onBusinessFail(ChainContext<DemoContext> chainContext, BusinessException e) {

    }

    @Override
    public void onTimeoutFail(ChainContext<DemoContext> chainContext) {

    }

}
注意
  1. 关注getDependsOnNodes()方法，要确定好各个节点的依赖情况，也就是正确编排好各个任务的顺序，注意只需要返回直接前置节点即可。
  2. chainContext链路上下文，该上下文还包含了其他信息，我们只需要关心内部的contextInfo即可，也就是操作chainContext.getContextInfo()
第四步，创建链路

DemoChain

import cc.jinhx.easytool.process.chain.*;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import cc.jinhx.easytool.process.demo.node.*;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * DemoChain
 *
 * @author jinhx
 * @since 2022-03-29
 */
@Slf4j
@Component
public class DemoChain extends AbstractChain<DemoContext> {

    private static final AtomicInteger CHAIN_THREAD_POOL_COUNTER = new AtomicInteger(0);

    private static final int CPU_NUM = Runtime.getRuntime().availableProcessors();

    /**
     * 自定义链路线程池
     */
    public static final ThreadPoolExecutor CHAIN_THREAD_POOL =
            new ThreadPoolExecutor(
                    2, CPU_NUM * 2,
                    10, TimeUnit.MINUTES,
                    new LinkedBlockingQueue<>(1024),
                    (Runnable r) -> new Thread(r, "chain_thread_" + CHAIN_THREAD_POOL_COUNTER.incrementAndGet()),
                    (r, executor) -> log.info("chain has bean rejected" + r));

    private final static long DEFAULT_CHAIN_TIMEOUT = 1000L;

    private final static long DEFAULT_NODE_TIMEOUT = 500L;

    @Override
    protected long getChainTimeout() {
        return DEFAULT_CHAIN_TIMEOUT;
    }

    @Override
    protected ExecutorService getThreadPool() {
        // 执行该链路的线程池
        return CHAIN_THREAD_POOL;
    }

    @Override
    protected Set<AbstractThreadContextConfig> getThreadContextInitConfigs() {
        return new HashSet<>(Collections.singletonList(new KeyThreadContextConfig<>("traceId", MDC::get, MDC::put, MDC::remove)));
    }

    @Override
    protected void checkParams(ChainContext<DemoContext> chainContext) {

    }

    /**
     * 设置节点信息，链路的执行顺序跟此处的添加顺序无关
     */
    @Override
    protected void setNodeInfo() {
        // 添加重试节点DemoGetDataANode，重试次数为1，并配置节点超时时间。执行遇到异常时重试执行该节点，达到最大重试次数后还未执行成功，则中断链路，并返回异常信息
        this.addRetryNode(DemoGetDataANode.class, ChainNode.RetryTimesEnum.ONE, DemoChain::getNodeTimeout);
        // 添加中断节点DemoGetDataBNode，DemoGetDataCNode，并配置节点超时时间。执行遇到异常时中断链路，并返回异常信息
        this.addInterruptNodes(Arrays.asList(DemoGetDataBNode.class, DemoGetDataCNode.class), DemoChain::getNodeTimeout);
        // 添加抛弃节点DemoGetDataDNode，并配置节点超时时间。执行遇到异常时抛弃该节点，继续执行后续节点
        this.addAbandonNode(DemoGetDataDNode.class, DemoChain::getNodeTimeout);
        // 添加中断节点DemoGetDataENode，DemoGetDataFNode，DemoGetDataGNode，并配置节点超时时间。执行遇到异常时中断链路，并返回异常信息
        this.addInterruptNodes(Arrays.asList(DemoGetDataENode.class, DemoGetDataFNode.class, DemoGetDataGNode.class), DemoChain::getNodeTimeout);
    }

    public static long getNodeTimeout() {
        return DEFAULT_NODE_TIMEOUT;
    }

}
注意
  1. 关注setNodeInfo()方法，如果少添加了某个节点，则链路没法正常执行起来，会报异常提示链路不完整。注意：链路的执行顺序跟此处的添加顺序无关。
第五步，编写单元测试类，如下

DemoTest

import cc.jinhx.easytool.process.ProcessResult;
import cc.jinhx.easytool.process.SpringContextConfig;
import cc.jinhx.easytool.process.chain.ChainContext;
import cc.jinhx.easytool.process.chain.ChainHandler;
import cc.jinhx.easytool.process.demo.chain.DemoChain;
import cc.jinhx.easytool.process.demo.context.DemoContext;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * DemoTest
 *
 * @author jinhx
 * @since 2022-03-21
 */
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringContextConfig.class)
public class DemoTest {

    @Test
    public void test1() {
        // 创建上下文
        ChainContext<DemoContext> chainContext = ChainContext.create(DemoContext.class);
        // 设置入参
        chainContext.getContextInfo().setReq("req");
        
        // 执行指定链路，并返回所有数据
        ProcessResult<DemoContext> processResult1 = ChainHandler.execute(DemoChain.class, chainContext);
        System.out.println(processResult1);
        
        // 执行指定链路，并返回指定数据
        ProcessResult<String> processResult2 = ChainHandler.execute(DemoChain.class, chainContext, DemoContext::getDataG);
        System.out.println(processResult2);
    }

}
说明
  1. ChainContext.create(TestContext.class)方法用于创建统一的上下文，该上下文还包含了其他信息，我们只需要关心内部的contextInfo即可，也就是操作chainContext.getContextInfo()
  2. ChainHandler.execute(DemoChain.class, chainContext)方法用于执行指定链路，包含多个重载方法，入参包括：链路类，上下文，要获取的数据的方法。
  3. 查看日志：需要注意链路内部打印的日志级别为info！可以通过getThreadContextInitConfigs()内置方法设置链路id，然后通过下面的命令查询
## 会有整个执行过程的细节日志
grep '链路id' xx.log

## 会有整个链路过程的细节日志，过滤一些可能无关的日志
grep '链路id' xx.log | grep 'process'

## 会有整个链路过程的细节日志，包括一些错误日志（错误栈信息可能换行）
grep -A 50 '链路id' xx.log | grep 'process'
天不生我小金
关注
  • 23
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python下Pandas的14个最佳特色功能.docx
06-11
14 Best Python Pandas Features Pandas is the most widely used tool for data munging. It contains high-level data structures and manipulation tools designed to make data analysis fast and easy. Python...
easy-api
小雨的光的博客
08-15 3045
什么样的场景需要easy-api？ （1）作为接口调用方，我们希望接口提供方不只是提供苍白的接口文档，最好能提供一个可视化界面调用一下，这样我们就能快速定位是参数问题还是调用逻辑问题； （2）作为接口提供方，接口调用方固执的认为是你的服务出了问题，你可以根据他给的参数在可视化界面里调用你的接口，成功的返回了数据，然后狠狠的告诉对方是他的服务出错了。 想想，如果真的有这样的工具，...
探索 EasyTool：一款强大且易用的 .NET 开发工具集
gitblog_00081的博客
04-03 243
探索 EasyTool：一款强大且易用的 .NET 开发工具集 项目地址:https://gitcode.com/dotnet-easy/easytool 项目简介 EasyTool 是一个开源的 .NET 库，旨在简化开发过程中的各种常见任务。它由 .NET Easy 团队打造，为开发者提供了一系列便捷的工具函数和类，覆盖了日志记录、文件操作、字符串处理、加密解密等多个领域。 技术分析 广泛的功...
GitLab 中文文档
peterxiaoq的专栏
09-05 3183
GitLab 中文文档 使用 .gitlab-ci.yml 配置project's builds 这篇文档讲述了.gitlab-ci.yml的用法，这个文件被 GitLab Runner用来控制project's builds流程。 如果你想快速了解 GitLab CI的介绍，可以阅读 GitLab CI快速入门. Table of Contents gener
easy-swagger
小雨的光的博客
07-22 753
为什么要选择easy-swagger？ 日常开发中，接口文档几乎是必不可少的一环，靠程序员自己维护接口文档 经常出现的几个问题是：需要额外花时间编写文档，从而导致更新不及时，维护又麻烦 。到最后，除非强制要求，否则接口文档几乎不可用了。 基于注解生成接口文档的swagger一开始的确缓解了程序员和接口文档之间的矛盾，但是 过分的植入注解导致的注解泛滥又让很多人...
EASY spa单页面版文档
Java技术乐园
07-01 5111
1.1.导入项目 下载项目后进行解压 使用IDEA、WebStorm、HBuilder等前端开发工具打开 打开index.html点击右上角浏览器图标运行： 注意：必须以http://的形式访问，而不是file://的形式访问。 1.2.项目结构 |-assets | |-images // 图片 | |-js | |-main.js // 入口js | |-libs // 第三方库，ech.
Hbase官方文档中文版
小宁哥博客
05-15 3781
版权声明：本文为博主原创文章，转载请标注博主链接： https://blog.csdn.net/qq_35036995/article/details/80320009 摘要 这是 Apache HBase (TM)的官方文档。 HBase是一个分布式，版本化，面向列的数据库，构建在 Apache Hadoop和 Apache ZooKeeper之上。   目录 序 1. 入门 1....
pandas documentation (文档)
既然选择了远方 便只顾风雨兼程 - 永强
11-05 439
pandas documentation (文档)
RF 命令参数说明文档
你知道的昵称
02-28 3376
C:\Users\xxx>robot -h Robot Framework -- A generic automation framework Version: 3.1.2 (Python 3.8.0 on win32) # 常见用法 Usage: robot [options] data_sources or: python -m robot [options] da...
EasyNVR & EasyNVS 视频监控系统测试部署文档
linux丶晨星
11-11 2334
——运维工程师.李晨星 文章目录一、项目需求二、EasyNVR1.EasyNVR的优点2.EasyNVR的缺点3. EasyNVR要面临的问题4. EasyNVR无法解决的方案5. EasyNVR主要功能三、EasyNVS1. EasyNVS的优点2. EasyNVR失控3.为什么用EasyNVS管理平台4. EasyNVS管理平台使用方式四、部署安装硬件推荐配置1. EasyNVR2. Ea...
idea下Easy Code配置
YangZF
09-30 1222
idea下Easy Code配置Type MapperTemplate SettingGlobal Config 这是一个自动生成代码（dao、mapper、entity、service、…）插件，只需配置一次，不像其他方法那样每个项目都去复制配置；插件的安装使用搜索一下有很多，例如 https://blog.csdn.net/qq_38225558/article/details/8447965...
基于Java的租房管理系统的设计与实现.doc
05-30
The whole system to meet the beautiful interface， easy operation， safety and the masses point of view as a concept, including the availability of information management， customer information ...
Flash电子相册的设计与制作.doc
02-27
个性化 Flash electronic album production 【Abstract】Flash is an authoring tool that designers and developers can use to create presentations, applications, and other content that allows the user to ...
EXCITE-FATIGUE-培训教程.pdf
12-25
EXCITE Fatigue is an advanced easy-to-use tool for durability analysis which interfaces to finite element models. § 它将疲劳分析所需的：动态载荷信息、有限元动态应力历程、材料疲劳特性结合起来， 可按...
Android代码-easy-guide-android
08-06
EasyGuide is an easy-to-use tool to create guide layer on Android using Kotlin, which supports adding highlight on any View on screen, or any item in RecyclerView or ListView, or any area in dialog....
java jar包如何运行或调用
NLP与推荐算法
05-08 234
java服务启动
CMS垃圾回收器为什么被移除
最新发布
m0_54187478的博客
05-10 294
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
C#(C Sharp)学习笔记_类【十五】
追求细节，成就完美
05-01 664
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
springboot集成easyword实现对word文档进行读取
03-21
可以使用Apache POI库来实现对Word文档的读取。在Spring Boot项目中，可以通过添加以下依赖来集成Apache POI： ``` <groupId>org.apache.poi <artifactId>poi <version>4.1.2 <groupId>org.apache.poi ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值