作业流——flow

不同的job之间有时都需要相同的几个step,并且调用step之间的顺序也是相同的,此时可以把这几个step组成一个flow会方便调用。一个job可以由flow和step共同组成。

这里写图片描述

flow流和flow流或者和tep步骤之间是可以进行跳转的,具体方法同上一章节作业步骤跳转相同,next()、from()、on()、to()同样适用。

下面看一下,step、flow和决策者之间的相互跳转

首先定义一个决策者

package com.lzj.spring.flow;

import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.job.flow.FlowExecutionStatus;
import org.springframework.batch.core.job.flow.JobExecutionDecider;

public class StepDecider implements JobExecutionDecider{

    private Boolean flag;

    public StepDecider(Boolean flag) {
        this.flag = flag;
    }

    @Override
    public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
        System.out.println("StepDecider决策者开始执行……");
        if (flag) {
            System.out.println("条件是name");
            return new FlowExecutionStatus("name");
        }else {
            System.out.println("条件是password");
            return new FlowExecutionStatus("password");
        }

    }

}

step、flow、决策者之间的跳转配置

package com.lzj.spring.flow;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.job.builder.FlowBuilder;
import org.springframework.batch.core.job.flow.Flow;
import org.springframework.batch.core.job.flow.JobExecutionDecider;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*@EnableBatchProcessing注解也可以加在spring boot的启动类上*/
@EnableBatchProcessing
@Configuration
public class BatchConfig {

    /*自动注入Step的工厂类,用于生成step*/
    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    /*自动注入Job的工厂类,用于生成job*/
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Bean
    public Step step1(){
        System.out.println("[This is step1]");
        Step step = stepBuilderFactory.get("step1").tasklet((contribution, chunkContext) -> {
            System.out.println("step1 process...");
            return RepeatStatus.FINISHED;
        }).build();
        return step;
    }

    @Bean
    public Step step2(){
        System.out.println("[This is step2]");
        Step step = stepBuilderFactory.get("step2").tasklet((contribution, chunkContext) -> {
            System.out.println("step2 process...");
            return RepeatStatus.FINISHED;
        }).build();
        return step;
    }

    @Bean
    public Step step3(){
        System.out.println("[This is step3]");
        Step step = stepBuilderFactory.get("step3").tasklet((contribution, chunkContext) -> {
            System.out.println("step3 process...");
            return RepeatStatus.FINISHED;
        }).build();
        return step;
    }

    @Bean
    public JobExecutionDecider getDecider(){
        return new StepDecider(true);
    }

    <!--定义flow1,flow1有step2、决策者组成-->
    @Bean
    public Flow flow1(){
        return new FlowBuilder<Flow>("flow1")
        .start(step2())     //可以start开始一个step、flow、决策者
        .from(step2()).on(ExitStatus.COMPLETED.getExitCode()).to(getDecider())
        .from(getDecider()).on("name").to(step1())  //可以to到一个step、flow、决策者
        .build();
    }

    /*job1由flow1和step3组成*/
    @Bean
    public Job job1(){
        Job job = jobBuilderFactory.get("job1")
                .start(flow1())
                .on(ExitStatus.COMPLETED.getExitCode()).to(step3())
                .end()
                .build();
        return job;
    }

}

运行该作业,输出日志

……省略日志
2018-03-01 09:45:52.203  INFO 9608 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step2]
step2 process...
StepDecider决策者开始执行……
条件是name
2018-03-01 09:45:52.250  INFO 9608 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step1]
step1 process...
2018-03-01 09:45:52.279  INFO 9608 --- [           main] o.s.batch.core.job.SimpleStepHandler     : Executing step: [step3]
step3 process...
PCIE(Peripheral Component Interconnect Express)是一种计算机扩展总线标准,用于连接外部设备与计算机主板之间的数据传输。PCIe连接的设备可以是显卡、声卡、网卡等。 Flow control(量控制)是PCIE中的一种基础机制,用于在设备之间传输数据时确保数据的可靠传输。 PCIE的flow control可以分为两种方式:Credit-based Flow Control(基于信用控制)和Acknowledgment/Negative Acknowledgment Flow Control(确认/否定确认控制)。 基于信用控制是PCIE中最常用的量控制机制。发送方设备在发送数据之前会向接收方设备发送一个信用(credit)值,表示发送方设备可以发送的最大数据量。接收方设备在接收到数据后会发回一个更新的信用值给发送方设备,发送方设备根据接收到的信用值确定下一次可以发送的数据量。通过这种方式,可以有效控制不同速度的设备之间的数据传输,避免数据丢失或信道阻塞。 确认/否定确认控制是PCIE中的一种备用方式,当发送方设备发送数据后,接收方设备会发回一个确认或否定确认信号给发送方设备,以告知是否成功接收数据。如果发送方设备收到否定确认信号,则会重新发送数据,确保数据的可靠性。 总结来说,PCIE中的flow control机制是为了确保数据的可靠传输而设计的。基于信用控制和确认/否定确认控制是两种常用的量控制方式,可以根据不同的需求选择适合的方式来控制数据的传输。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值