Spring Batch之拦截器汇总（二十二）

原创已于 2022-01-26 09:03:20 修改 · 1.4k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#spring #batch #java

于 2022-01-11 20:24:07 首次发布

Spring Batch 专栏收录该内容

41 篇文章

订阅专栏

一、Job级拦截器

Spring Batch之Job级拦截器实现(四)_人……杰的博客-CSDN博客

二、Step级拦截器

Spring Batch之Step级拦截器实现(十三)_人……杰的博客-CSDN博客

三、ChunkListener

主要操作：Chunk执行前、Chunk执行后。

（1）实现接口方式：

接口ChunkListener声明如下：

public interface ChunkListener extends StepListener {

    void beforeChunk(ChunkContext var1);

    void afterChunk(ChunkContext var1);

    void afterChunkError(ChunkContext var1);
}

beforeChunk():在Chunk执行前触发，在Step事务中(同@BeforeChunk)
afterChunk():在Chunk执行后触发，不在Step事务中(同@AfterChunk)

（2）通过Annotation机制方式

@BeforeChunk
@AfterChunk

四、ItemReadListener

主要操作：在Chunk读阶段的拦截器，可以在读之前、读之后、读发生异常时候触发该拦截器。

（1）实现接口方式：

接口ItemReadListener声明如下：

public interface ItemReadListener<T> extends StepListener {
    void beforeRead();

    void afterRead(T var1);

    void onReadError(Exception var1);
}

beforeRead():在ItemReader#read()之前执行(同@BeforeRead)
afterRead():在ItemReader#read()之后执行(同@AfterRead)
onReadError():当ItemReader#read()抛出异常时候触发该操作(同@OnReadError)

（2）通过Annotation机制方式

@BeforeRead
@AfterRead
@OnReadError

五、ItemProcessListener

主要操作：在Chunk处理阶段的拦截器，可以在处理之前、处理之后、处理发生异常时候触发该拦截器。

（1）实现接口方式：

接口ItemProcessListener声明如下：

public interface ItemProcessListener<T, S> extends StepListener {
    void beforeProcess(T var1);

    void afterProcess(T var1, S var2);

    void onProcessError(T var1, Exception var2);
}

beforeProcess():在ItemProcessor.process()之前执行(同@BeforeProcess)
afterProcess():在ItemProcessor.process()之后执行，即使process方法返回null，仍然会触发拦截器操作(同@AfterProcess)
onProcessError():当ItemProcessor.process()抛出异常时触发该操作(同@OnProcessError)

（2）通过Annotation机制方式

@BeforeProcess
@AfterProcess
@OnProcessError

六、ItemWriteListener

主要操作：在Chunk写阶段的拦截器，可以在写之前、写之后、写发生异常时候触发该拦截器。

（1）实现接口方式：

接口ItemWriteListener声明如下：

public interface ItemWriteListener<S> extends StepListener {
    void beforeWrite(List<? extends S> var1);

    void afterWrite(List<? extends S> var1);

    void onWriteError(Exception var1, List<? extends S> var2);
}

beforeWrite():在ItemWrite#write()之前执行(同@BeforeWrite)
afterWrite():在ItemWrite#write()之后执行，该操作会在事务提交之前、ChunkListener#afterChunk()之前执行(同@AfterWrite)
onWriteError():在ItemWrite#write()抛出异常时触发该操作(同@OnWriteError)

（2）通过Annotation机制方式

@BeforeWrite
@AfterWrite
@OnWriteError

七、SkipListener

主要操作：SkipListener在Chunk处理阶段抛出跳过定义的异常时触发，在Chunk读、处理、写阶段发生的异常都会触发该拦截器。

（1）实现接口方式：

接口SkipListener声明如下：

public interface SkipListener<T, S> extends StepListener {
    void onSkipInRead(Throwable var1);

    void onSkipInWrite(S var1, Throwable var2);

    void onSkipInProcess(T var1, Throwable var2);
}

onSkipInRead():在读阶段发生异常并且配置了异常可以跳过时触发该操作(同@OnSkipInRead)
onSkipInWrite():在写阶段发生异常并且配置了异常可以跳过时触发该操作(同@OnSkipInWrite)
onSkipInProcess():在处理阶段发生异常并且配置了异常可以跳过时触发该操作(同@OnSkipInProcess)

（2）通过Annotation机制方式

@OnSkipInRead
@OnSkipInWrite
@OnSkipInProcess

八、RetryListener

主要操作：RetryListener在Chunk处理阶段抛出重试定义的异常时触发，通过拦截器可以在重试动作发生时进行日志记录、收集重试信息等。可以直接实现接口RetryListener，也可以直接继承RetryListenerSupport，通常只需要实现onError操作，在重试发生错误时触发该操作。

（1）实现接口方式：

接口RetryListener声明如下：

public interface RetryListener {
    <T, E extends Throwable> boolean open(RetryContext var1, RetryCallback<T, E> var2);

    <T, E extends Throwable> void close(RetryContext var1, RetryCallback<T, E> var2, Throwable var3);

    <T, E extends Throwable> void onError(RetryContext var1, RetryCallback<T, E> var2, Throwable var3);
}

open():在进入retry之前执行该操作，可以在该操作中准备重试需要的资源；如果该操作返回false，将会终止本次重试操作，且会抛出异常：org.springframework.batch.retry.TerminatedRetryException.
close():在retry结束之前执行该操作，可以在该方法中关闭在open操作中打开的资源
onError():重试发生错误时触发该操作

九、拦截器执行顺序

拦截器根据作用域的代销分别执行对应的before和after操作，其中读、处理、写三个拦截器没有嵌套关系，三者按照顺序先后执行。拦截器先后执行顺序入下：

十、项目实例

1.项目架构

2.代码实现

Demo18BatchMain.java:

package com.xj.demo18;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Demo18BatchMain {
    public static void main(String[] args) {
        Demo18BatchMain batchMain = new Demo18BatchMain();
        batchMain.executeJob("demo18/job/demo18-job.xml", "listenerJob", "jobLauncher", new JobParametersBuilder().toJobParameters());
    }

    /**
     *执行Job
     * @param jobXmlPath 配置job的xml文件路径
     * @param jobId job的id
     * @param jobLauncherId jobLauncher的id
     * @param jobParameters 参数
     */
    public void executeJob(String jobXmlPath, String jobId, String jobLauncherId, JobParameters jobParameters){
        ApplicationContext context = new ClassPathXmlApplicationContext(jobXmlPath);
        JobLauncher jobLauncher = (JobLauncher) context.getBean(jobLauncherId);
        //获取要执行的Job
        Job job = (Job)context.getBean(jobId);

        try{
            //开始执行作业Job
            JobExecution jobExecution =  jobLauncher.run(job, jobParameters);
            //输出执行结果
            System.out.println(jobExecution.toString());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

AutoReader.java:

package com.xj.demo18;

import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.NonTransientResourceException;
import org.springframework.batch.item.ParseException;
import org.springframework.batch.item.UnexpectedInputException;

public class AutoReader implements ItemReader<String> {
    private int count = 0;
    private int maxCount = 30;
    @Override
    public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {

        if(count > maxCount){
            return null;
        }else{
            count++;
            System.out.println("reader--->" + count);
            return count + "";
        }
    }

    public void setMaxCount(int maxCount) {
        this.maxCount = maxCount;
    }

    public int getMaxCount() {
        return maxCount;
    }
}

AutoWriter.java:

package com.xj.demo18;

import org.springframework.batch.item.ItemWriter;
import java.util.List;

public class AutoWriter implements ItemWriter<String> {
    @Override
    public void write(List<? extends String> list) throws Exception {
        System.out.println("Writer Begin!");
        for(String item : list){
            System.out.println("Writer --->" + item);
        }
        System.out.println("Writer End!");
    }
}

PassProcessor.java:

package com.xj.demo18;

import org.springframework.batch.item.ItemProcessor;

public class PassProcessor<T> implements ItemProcessor<T,T> {
    @Override
    public T process(T t) throws Exception {
        System.out.println("processor:" + (String) t);
        return t;
    }
}

SystemOutJobExecutionListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;

public class SystemOutJobExecutionListener implements JobExecutionListener {

	/* (non-Javadoc)
	 * @see org.springframework.batch.core.JobExecutionListener#beforeJob(org.springframework.batch.core.JobExecution)
	 */
	public void beforeJob(JobExecution jobExecution) {
		System.out.println("JobExecutionListener.beforeJob()");
	}

	/* (non-Javadoc)
	 * @see org.springframework.batch.core.JobExecutionListener#afterJob(org.springframework.batch.core.JobExecution)
	 */
	public void afterJob(JobExecution jobExecution) {
		System.out.println("JobExecutionListener.afterJob()");
	}

}

SystemOutStepExecutionListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.StepExecutionListener;

/**
 * @author bruce.liu(mailto:jxta.liu@gmail.com)
 * 2013-3-21下午10:52:28
 */
public class SystemOutStepExecutionListener implements StepExecutionListener {

	/* (non-Javadoc)
	 * @see org.springframework.batch.core.StepExecutionListener#beforeStep(org.springframework.batch.core.StepExecution)
	 */
	public void beforeStep(StepExecution stepExecution) {
		System.out.println("StepExecutionListener.beforeStep()");
	}

	/* (non-Javadoc)
	 * @see org.springframework.batch.core.StepExecutionListener#afterStep(org.springframework.batch.core.StepExecution)
	 */
	public ExitStatus afterStep(StepExecution stepExecution) {
		System.out.println("StepExecutionListener.afterStep()");
		return null;
	}

}

SystemOutChunkListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.ChunkListener;
import org.springframework.batch.core.scope.context.ChunkContext;

public class SystemOutChunkListener implements ChunkListener {

	@Override
	public void beforeChunk(ChunkContext context) {
		System.out.println("ChunkListener.beforeChunk()");
	}

	@Override
	public void afterChunk(ChunkContext context) {
		System.out.println("ChunkListener.afterChunk()");
	}

	@Override
	public void afterChunkError(ChunkContext context) {
		System.out.println("ChunkListener.afterChunkError()");
	}

}

SystemOutItemReadListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.ItemReadListener;

public class SystemOutItemReadListener implements ItemReadListener<String> {

	public void beforeRead() {
		System.out.println("ItemReadListener.beforeRead()");
	}

	public void afterRead(String item) {
		System.out.println("ItemReadListener.afterRead()");
	}

	public void onReadError(Exception ex) {
		System.out.println("ItemReadListener.onReadError()");
	}

}

SystemOutItemProcessListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.ItemProcessListener;

public class SystemOutItemProcessListener implements ItemProcessListener<String, String> {

	public void beforeProcess(String item) {
		System.out.println("ItemProcessListener.beforeProcess()");
	}

	public void afterProcess(String item, String result) {
		System.out.println("ItemProcessListener.afterProcess()");
	}

	public void onProcessError(String item, Exception e) {
		System.out.println("ItemProcessListener.onProcessError()");
	}

}

SystemOutItemWriteListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.ItemWriteListener;

import java.util.List;

public class SystemOutItemWriteListener implements ItemWriteListener<String> {

	public void beforeWrite(List<? extends String> items) {
		System.out.println("ItemWriteListener.beforeWrite()");		
	}

	public void afterWrite(List<? extends String> items) {
		System.out.println("ItemWriteListener.afterWrite()");		
	}

	public void onWriteError(Exception exception, List<? extends String> items) {
		System.out.println("ItemWriteListener.onWriteError()");		
	}

}

SystemOutSkipListener.java:

package com.xj.demo18.listener;

import org.springframework.batch.core.SkipListener;

public class SystemOutSkipListener implements SkipListener<String, String> {

	public void onSkipInRead(Throwable t) {
		System.out.println("SkipListener.onSkipInRead()");		
	}

	public void onSkipInWrite(String item, Throwable t) {
		System.out.println("SkipListener.onSkipInWrite()");
	}

	public void onSkipInProcess(String item, Throwable t) {
		System.out.println("SkipListener.onSkipInProcess()");		
	}

}

SystemOutRetryListener.java:

package com.xj.demo18.listener;

import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;
import org.springframework.retry.RetryListener;

public class SystemOutRetryListener implements RetryListener {

	@Override
	public <T, E extends Throwable> boolean open(RetryContext retryContext, RetryCallback<T, E> retryCallback) {
		System.out.println("RetryListener.open()");
		return true;
	}

	@Override
	public <T, E extends Throwable> void close(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {
		System.out.println("RetryListener.close()");
	}

	@Override
	public <T, E extends Throwable> void onError(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {
		System.out.println("RetryListener.onError()");
	}
}

demo18-job.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:batch="http://www.springframework.org/schema/batch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch.xsd">

    <import resource="classpath:demo18/job/demo18-jobContext.xml"/>
    <import resource="classpath:demo18/job/demo18-jobListener.xml"/>

    <batch:job id="listenerJob">
        <batch:step id="listenerStep">
            <batch:tasklet>
                <batch:chunk reader="reader" processor="processor" writer="writer" commit-interval="1" retry-limit="1">
                    <!--重试拦截器-->
                    <batch:retry-listeners>
                        <batch:listener ref="retryListener"/>
                    </batch:retry-listeners>
                    <batch:retryable-exception-classes>
                        <batch:include class="java.lang.RuntimeException"/>
                    </batch:retryable-exception-classes>
                    <batch:listeners>
                        <!--Chunk级拦截器-->
                        <batch:listener ref="chunkListener"/>
                        <!--ItemRead级拦截器-->
                        <batch:listener ref="itemReadListener"/>
                        <!--ItemProcess级拦截器-->
                        <batch:listener ref="itemProcessListener"/>
                        <!--ItemWrite级拦截器-->
                        <batch:listener ref="itemWriteListener"/>
                        <!--跳过拦截器-->
                        <batch:listener ref="skipListener"/>
                    </batch:listeners>
                </batch:chunk>
            </batch:tasklet>
            <batch:listeners>
                <!--Step级拦截器-->
                <batch:listener ref="stepExecutionListener"/>
            </batch:listeners>
        </batch:step>
        <batch:listeners>
            <!--Job级拦截器-->
            <batch:listener ref="jobExecutionListener"/>
        </batch:listeners>
    </batch:job>

</beans>

demo18-jobListener.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--定义各种拦截器-->
    <bean id="jobExecutionListener" class="com.xj.demo18.listener.SystemOutJobExecutionListener" />
    <bean id="stepExecutionListener" class="com.xj.demo18.listener.SystemOutStepExecutionListener" />
    <bean id="chunkListener" class="com.xj.demo18.listener.SystemOutChunkListener" />
    <bean id="itemReadListener" class="com.xj.demo18.listener.SystemOutItemReadListener" />
    <bean id="itemProcessListener" class="com.xj.demo18.listener.SystemOutItemProcessListener" />
    <bean id="itemWriteListener" class="com.xj.demo18.listener.SystemOutItemWriteListener" />
    <bean id="retryListener" class="com.xj.demo18.listener.SystemOutRetryListener" />
    <bean id="skipListener" class="com.xj.demo18.listener.SystemOutSkipListener" />

</beans>

demo18-jobContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"/>

    <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager"/>

    <bean id="reader" class="com.xj.demo18.AutoReader" >
        <property name="maxCount" value="0" />
    </bean>

    <bean id="writer" class="com.xj.demo18.AutoWriter" />

    <bean id="processor" class="com.xj.demo18.PassProcessor"/>

</beans>