堆棧內存溢出
  簡體   English   中英

Null 指針在 Spring 批處理中的步驟之間傳遞值異常

[英]Null Pointer Exception on passing the value between steps in Spring Batch

 原文  2020-06-03 23:15:50  6   1    spring/ spring-boot/ spring-batch/ batch-processing/ spring-framework-beans

問題描述

我正在學習 Spring Batch 並且我正在做一個示例程序，我需要在其中將值從一個步驟傳遞到另一個步驟。

場景：我有一個人員表，我從中提取人員詳細信息，將幾列保存到 DTO（在步驟 1 的 ItemWriter 中）並將值從 DTO 傳遞到 where 子句上的另一個表從中提取相關值（在第 2 步的 ItemReader 中）。 最后，我將生成具有所有這些值的 CSV。

這是我的代碼：

@Bean
    public Job job() throws UnexpectedInputException, ParseException, NonTransientResourceException, Exception {
        return jobBuilderFactory.get("readDBJob").incrementer(new RunIdIncrementer()).start(step1()).next(step2())
                .build();
    }

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1").<Person, Person>chunk(500000).reader(itemReader())
            .writer(itemWriter()).listener(promotionListener()).build();
}

@Bean
    public Step step2() throws UnexpectedInputException, ParseException, NonTransientResourceException, Exception {
        return stepBuilderFactory.get("step2").<Person, Result>chunk(100)
                .reader(readingObjectItemReader.cursorReader()).writer(itemWriterForStep2()).build();
    }

第 1 步的 ItemWriter：

        @Bean
public ItemWriter<Person> itemWriter() {
    return new ItemWriter<Person>() {

        private StepExecution stepExecution;
        List<personDTO> responseList = null;

        @Override
        public void write(List<? extends Person> items) throws Exception {
            for (Person item : items) {
                personDTO responseObject = new personDTO();
                BeanUtils.copyProperties(item, responseObject);
                if(responseObject != null && responseObject.getPersonId() != null) {
                    if(stepExecution.getExecutionContext().containsKey("personDtoObject")) {
                        responseList = (List<personDTO>) this.stepExecution.getExecutionContext().get("personDtoObject");
                    }
                    responseList.add(responseObject);
                    this.stepExecution.getExecutionContext().put("personDtoObject", responseList);
                }
            }
        }

        @BeforeStep
        public void saveStepExecution(StepExecution stepExecution) { 
            this.stepExecution = stepExecution;
            this.stepExecution.getExecutionContext().put("personDtoObject", new ArrayList<>());
        }
}

作業執行上下文：

    @Bean
    public Object promotionListener() { 
        ExecutionContextPromotionListener listener = new ExecutionContextPromotionListener();
        listener.setKeys(new String[] {"personDtoObject"});
        listener.setStrict(true);
        return listener;
    }

這是我嘗試在步驟 2 ItemReader 中訪問值的方式

公共 class ReadingObjectItemReader 實現 ItemReader {

@Autowired
DataSource dataSource;

private List<personDTO> personDtoList;

String value;


@Override
public personDetails read()
        throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
    return null;
}

@Bean
public JdbcCursorItemReader<personDetails> cursorReader() {

    System.out.println("Values from the step 1 " + personDtoList);
    ....
}

@BeforeStep
public void retrieveSharedData(StepExecution stepExecution) {
    JobExecution jobExecution = stepExecution.getJobExecution();
    ExecutionContext jobContext = jobExecution.getExecutionContext();
    personDtoList=  (List<personDTO>) jobContext.get("personDtoObject");
}

}

當我嘗試在第 2 步中訪問 personDtoList 的值時，我得到了 null。 我在步驟 1 完成之前驗證了 StepContext 中的值，一切看起來都很好，但是當嘗試在步驟 2 中訪問它們時，我得到 null。

我查看了大多數在線可用資源，但我無法弄清楚我哪里出錯了。 任何幫助表示贊賞。

我在這里先向您的幫助表示感謝。

1 個解決方案

解決方案1
 1 已采納  2020-06-04 11:04:23

在步驟 1 的項目編寫器中，您正在執行以下操作：

ExecutionContext stepContext = this.stepExecution.getExecutionContext();
stepContext.put("personDtoObject", responseList);

這意味着您將覆蓋每個塊的先前列表。 您需要做的是從執行上下文中獲取列表並在覆蓋鍵之前在其中添加項目。 您還需要在步驟邊界（也就是第一個塊和最后一個塊）添加一些完整性檢查，以確保列表已初始化並且在將其放入執行上下文之前它不是null （尤其是最后一個塊）。

編輯：添加促銷偵聽器工作所需的代碼更改

您還需要將 PromotionListener promotionListener()方法的返回類型從Object為ExecutionContextPromotionListener ：

@Bean
public ExecutionContextPromotionListener promotionListener() { 
    ExecutionContextPromotionListener listener = new ExecutionContextPromotionListener();
    listener.setKeys(new String[] {"personDtoObject"});
    listener.setStrict(true);
    return listener;
}

否則，此 bean 未正確注冊為偵聽器。 這是一個完整的例子：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.annotation.BeforeStep;
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.launch.JobLauncher;
import org.springframework.batch.core.listener.ExecutionContextPromotionListener;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.support.ListItemReader;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableBatchProcessing
public class MyJob {

    private JobBuilderFactory jobBuilderFactory;
    private StepBuilderFactory stepBuilderFactory;

    public MyJob(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public ItemReader<Integer> itemReader() {
        return new ListItemReader<>(Arrays.asList(1, 2, 3, 4));
    }

    @Bean
    public ItemWriter<Integer> itemWriter() {
        return new ItemWriter<Integer>() {

            private StepExecution stepExecution;

            @Override
            public void write(List<? extends Integer> items) {
                List<Integer> itemsList = (List<Integer>) stepExecution.getExecutionContext().get("items");
                for (Integer item : items) {
                    System.out.println("item = " + item);
                    itemsList.add(item);
                }
            }

            @BeforeStep
            public void saveStepExecution(StepExecution stepExecution) {
                this.stepExecution = stepExecution;
                this.stepExecution.getExecutionContext().put("items", new ArrayList<>());
            }
        };
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<Integer, Integer>chunk(2)
                .reader(itemReader())
                .writer(itemWriter())
                .listener(promotionListener())
                .build();
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .tasklet((contribution, chunkContext) -> {
                    ExecutionContext executionContext = contribution.getStepExecution().getJobExecution().getExecutionContext();
                    List<Integer> items = (List<Integer>) executionContext.get("items");
                    System.out.println("Items read in step1:");
                    for (Integer item : items) {
                        System.out.println("item = " + item);
                    }
                    return RepeatStatus.FINISHED;
                })
                .build();
    }

    @Bean
    public ExecutionContextPromotionListener promotionListener() {
        ExecutionContextPromotionListener listener = new ExecutionContextPromotionListener();
        listener.setKeys(new String[]{"items"});
        listener.setStrict(true);
        return listener;
    }

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .start(step1())
                .next(step2())
                .build();
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyJob.class);
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean(Job.class);
        jobLauncher.run(job, new JobParameters());
    }

}

打印：

item = 1
item = 2
item = 3
item = 4
Items read in step1:
item = 1
item = 2
item = 3
item = 4

編輯 2：添加面向塊的步驟的示例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.annotation.BeforeStep;
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.launch.JobLauncher;
import org.springframework.batch.core.listener.ExecutionContextPromotionListener;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.support.ListItemReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableBatchProcessing
public class MyJob {

    private JobBuilderFactory jobBuilderFactory;
    private StepBuilderFactory stepBuilderFactory;

    public MyJob(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public ItemReader<Integer> itemReader() {
        return new ListItemReader<>(Arrays.asList(1, 2, 3, 4));
    }

    @Bean
    public ItemWriter<Integer> itemWriter() {
        return new ItemWriter<Integer>() {

            private StepExecution stepExecution;

            @Override
            public void write(List<? extends Integer> items) {
                List<Integer> itemsList = (List<Integer>) stepExecution.getExecutionContext().get("items");
                for (Integer item : items) {
                    System.out.println("item = " + item);
                    itemsList.add(item);
                }
            }

            @BeforeStep
            public void saveStepExecution(StepExecution stepExecution) {
                this.stepExecution = stepExecution;
                this.stepExecution.getExecutionContext().put("items", new ArrayList<>());
            }
        };
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<Integer, Integer>chunk(2)
                .reader(itemReader())
                .writer(itemWriter())
                .listener(promotionListener())
                .build();
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .<Integer, Integer>chunk(2)
                .reader(new ReadingObjectItemReader())
                .writer(items -> items.forEach((Consumer<Integer>) integer -> System.out.println("integer = " + integer)))
                .build();
    }

    @Bean
    public ExecutionContextPromotionListener promotionListener() {
        ExecutionContextPromotionListener listener = new ExecutionContextPromotionListener();
        listener.setKeys(new String[]{"items"});
        listener.setStrict(true);
        return listener;
    }

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .start(step1())
                .next(step2())
                .build();
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyJob.class);
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean(Job.class);
        jobLauncher.run(job, new JobParameters());
    }

    public static class ReadingObjectItemReader implements ItemReader<Integer> {

        int i = 0;
        private List<Integer> items;

        @Override
        public Integer read() {
            if (i >= items.size()) {
                return null;
            } else {
                return items.get(i++);
            }
        }

        @BeforeStep
        public void retrieveSharedData(StepExecution stepExecution) {
            JobExecution jobExecution = stepExecution.getJobExecution();
            ExecutionContext jobContext = jobExecution.getExecutionContext();
            items =  (List<Integer>) jobContext.get("items");
        }
    }

}

印刷：

item = 1
item = 2
item = 3
item = 4
integer = 1
integer = 2
integer = 3
integer = 4

這意味着該列表已在步驟 2 中從作業執行上下文中正確檢索，這是一個面向塊的步驟。

暫無
暫無

聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

相關問題 Spring Batch SystemCommandTasklet拋出空指針異常 春季批睡眠之間的步驟 空指針異常-彈簧3 Spring和空指針異常 在一個步驟中發生異常的情況下，春季批處理回滾所有步驟 Spring Mail中的空指針異常 Spring安全空指針異常 空指針異常EntityManager彈簧 spring和MessagesSource空指針異常 Spring框架空指針異常
相關標簽
 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM