温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

Spring Batch的概念和作用是什么

发布时间:2021-06-22 17:56:11 来源:亿速云 阅读:195 作者:chen 栏目:开发技术

这篇文章主要讲解了“Spring Batch的概念和作用是什么”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Spring Batch的概念和作用是什么”吧!

目录
  • 一、Spring Batch的概念知识

    • 1.1、分层架构

    • 1.2、关键概念

      • 1.2.1、JobRepository

      • 1.2.2、任务启动器JobLauncher

      • 1.2.3、任务Job

      • 1.2.4、步骤Step

      • 1.2.5、输入——处理——输出

  • 二、代码实例

    • 2.1、基本框架

      • 2.2、输入——处理——输出

        • 2.2.1、读取ItemReader

        • 2.2.2、处理ItemProcessor

        • 2.2.3、输出ItremWriter

      • 2.3、Step

        • 2.4、Job

          • 2.5、运行

          • 三、监听Listener

            一、Spring Batch的概念知识

            1.1、分层架构

            Spring Batch的分层架构图如下:

            Spring Batch的概念和作用是什么

            可以看到它分为三层,分别是:

            • Application应用层:包含了所有任务batch jobs和开发人员自定义的代码,主要是根据项目需要开发的业务流程等。

            • Batch Core核心层:包含启动和管理任务的运行环境类,如JobLauncher等。

            • Batch Infrastructure基础层:上面两层是建立在基础层之上的,包含基础的读入reader写出writer、重试框架等。

            1.2、关键概念

            理解下图所涉及的概念至关重要,不然很难进行后续开发和问题分析。

            Spring Batch的概念和作用是什么

            1.2.1、JobRepository

            专门负责与数据库打交道,对整个批处理的新增、更新、执行进行记录。所以Spring Batch是需要依赖数据库来管理的。

            1.2.2、任务启动器JobLauncher

            负责启动任务Job

            1.2.3、任务Job

            Job是封装整个批处理过程的单位,跑一个批处理任务,就是跑一个Job所定义的内容。

            Spring Batch的概念和作用是什么

            上图介绍了Job的一些相关概念:

            • Job:封装处理实体,定义过程逻辑。

            • JobInstanceJob的运行实例,不同的实例,参数不同,所以定义好一个Job后可以通过不同参数运行多次。

            • JobParameters:与JobInstance相关联的参数。

            • JobExecution:代表Job的一次实际执行,可能成功、可能失败。

            所以,开发人员要做的事情,就是定义Job

            1.2.4、步骤Step

            Step是对Job某个过程的封装,一个Job可以包含一个或多个Step,一步步的Step按特定逻辑执行,才代表Job执行完成。

            Spring Batch的概念和作用是什么

            通过定义Step来组装Job可以更灵活地实现复杂的业务逻辑。

            1.2.5、输入——处理——输出

            所以,定义一个Job关键是定义好一个或多个Step,然后把它们组装好即可。而定义Step有多种方法,但有一种常用的模型就是输入——处理——输出,即Item ReaderItem ProcessorItem Writer。比如通过Item Reader从文件输入数据,然后通过Item Processor进行业务处理和数据转换,最后通过Item Writer写到数据库中去。

            Spring Batch为我们提供了许多开箱即用的ReaderWriter,非常方便。

            二、代码实例

            理解了基本概念后,就直接通过代码来感受一下吧。整个项目的功能是从多个csv文件中读数据,处理后输出到一个csv文件。

            2.1、基本框架

            添加依赖:

            <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-batch</artifactId>
            </dependency>
            <dependency>
              <groupId>com.h3database</groupId>
              <artifactId>h3</artifactId>
              <scope>runtime</scope>
            </dependency>

            需要添加Spring Batch的依赖,同时使用H2作为内存数据库比较方便,实际生产肯定是要使用外部的数据库,如OraclePostgreSQL

            入口主类:

            @SpringBootApplication
            @EnableBatchProcessing
            public class PkslowBatchJobMain {
                public static void main(String[] args) {
                    SpringApplication.run(PkslowBatchJobMain.class, args);
                }
            }

            也很简单,只是在Springboot的基础上添加注解@EnableBatchProcessing

            领域实体类Employee

            package com.pkslow.batch.entity;
            public class Employee {
                String id;
                String firstName;
                String lastName;
            }

            对应的csv文件内容如下:

            id,firstName,lastName

            1,Lokesh,Gupta

            2,Amit,Mishra

            3,Pankaj,Kumar

            4,David,Miller

            2.2、输入——处理——输出

            2.2.1、读取ItemReader

            因为有多个输入文件,所以定义如下:

            @Value("input/inputData*.csv")
            private Resource[] inputResources;
            
            @Bean
            public MultiResourceItemReader<Employee> multiResourceItemReader()
            {
              MultiResourceItemReader<Employee> resourceItemReader = new MultiResourceItemReader<Employee>();
              resourceItemReader.setResources(inputResources);
              resourceItemReader.setDelegate(reader());
              return resourceItemReader;
            }
            
            @Bean
            public FlatFileItemReader<Employee> reader()
            {
              FlatFileItemReader<Employee> reader = new FlatFileItemReader<Employee>();
              //跳过csv文件第一行,为表头
              reader.setLinesToSkip(1);
              reader.setLineMapper(new DefaultLineMapper() {
                {
                  setLineTokenizer(new DelimitedLineTokenizer() {
                    {
                      //字段名
                      setNames(new String[] { "id", "firstName", "lastName" });
                    }
                  });
                  setFieldSetMapper(new BeanWrapperFieldSetMapper<Employee>() {
                    {
                      //转换化后的目标类
                      setTargetType(Employee.class);
                    }
                  });
                }
              });
              return reader;
            }

            这里使用了FlatFileItemReader,方便我们从文件读取数据。

            2.2.2、处理ItemProcessor

            为了简单演示,处理很简单,就是把最后一列转为大写:

            public ItemProcessor<Employee, Employee> itemProcessor() {
              return employee -> {
                employee.setLastName(employee.getLastName().toUpperCase());
                return employee;
              };
            }
            2.2.3、输出ItremWriter

            比较简单,代码及注释如下:

            private Resource outputResource = new FileSystemResource("output/outputData.csv");
            
            @Bean
            public FlatFileItemWriter<Employee> writer()
            {
              FlatFileItemWriter<Employee> writer = new FlatFileItemWriter<>();
              writer.setResource(outputResource);
              //是否为追加模式
              writer.setAppendAllowed(true);
              writer.setLineAggregator(new DelimitedLineAggregator<Employee>() {
                {
                  //设置分割符
                  setDelimiter(",");
                  setFieldExtractor(new BeanWrapperFieldExtractor<Employee>() {
                    {
                      //设置字段
                      setNames(new String[] { "id", "firstName", "lastName" });
                    }
                  });
                }
              });
              return writer;
            }

            2.3、Step

            有了Reader-Processor-Writer后,就可以定义Step了:

            @Bean
            public Step csvStep() {
              return stepBuilderFactory.get("csvStep").<Employee, Employee>chunk(5)
                .reader(multiResourceItemReader())
                .processor(itemProcessor())
                .writer(writer())
                .build();
            }

            这里有一个chunk的设置,值为5,意思是5条记录后再提交输出,可以根据自己需求定义。

            2.4、Job

            完成了Step的编码,定义Job就容易了:

            @Bean
            public Job pkslowCsvJob() {
              return jobBuilderFactory
                .get("pkslowCsvJob")
                .incrementer(new RunIdIncrementer())
                .start(csvStep())
                .build();
            }

            2.5、运行

            完成以上编码后,执行程序,结果如下:

            Spring Batch的概念和作用是什么

            成功读取数据,并将最后字段转为大写,并输出到outputData.csv文件。

            三、监听Listener

            可以通过Listener接口对特定事件进行监听,以实现更多业务功能。比如如果处理失败,就记录一条失败日志;处理完成,就通知下游拿数据等。

            我们分别对ReadProcessWrite事件进行监听,对应分别要实现ItemReadListener接口、ItemProcessListener接口和ItemWriteListener接口。因为代码比较简单,就是打印一下日志,这里只贴出ItemWriteListener的实现代码:

            public class PkslowWriteListener implements ItemWriteListener<Employee> {
                private static final Log logger = LogFactory.getLog(PkslowWriteListener.class);
                @Override
                public void beforeWrite(List<? extends Employee> list) {
                    logger.info("beforeWrite: " + list);
                }
            
                @Override
                public void afterWrite(List<? extends Employee> list) {
                    logger.info("afterWrite: " + list);
                }
            
                @Override
                public void onWriteError(Exception e, List<? extends Employee> list) {
                    logger.info("onWriteError: " + list);
                }
            }

            把实现的监听器listener整合到Step中去:

            @Bean
            public Step csvStep() {
              return stepBuilderFactory.get("csvStep").<Employee, Employee>chunk(5)
                .reader(multiResourceItemReader())
                .listener(new PkslowReadListener())
                .processor(itemProcessor())
                .listener(new PkslowProcessListener())
                .writer(writer())
                .listener(new PkslowWriteListener())
                .build();
            }

            执行后看一下日志:

            Spring Batch的概念和作用是什么

            这里就能明显看到之前设置的chunk的作用了。Writer每次是处理5条记录,如果一条输出一次,会对IO造成压力。

            感谢各位的阅读,以上就是“Spring Batch的概念和作用是什么”的内容了,经过本文的学习后,相信大家对Spring Batch的概念和作用是什么这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是亿速云,小编将为大家推送更多相关知识点的文章,欢迎关注!

            向AI问一下细节

            免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

            AI