Spring-Batch学习总结（1）——重要概念，环境搭建，名词解释，第一个项目及异常处理

Spring-batch框架学习总结（1）
一．初识Spring-batch框架：
1.核心名词解释：
Job：是Spring-batch框架的核心概念，它包含了批处理的所有操作
Step:每一个Job由一个或多个Step组成，每个Step中涉及到itemReader,itemProcessor,ItemWriter,这三个接口顾名思义，一个负责数据源，一个负责业务逻辑，一个负责处理后的数据输出;
JobRepository:定义Job时，需要指定一个JobRepository，用来存储Job在运行过程中的状态信息，对于存储状态信息的原因为：如果Job运行失败了，Spring支持从失败的地方重新运行，而不是从头开始;
JobLauncher:很好理解launchuer是用来执行Job的，如果不设置，系统也会默认给Job配置默认的Launcher;
2.图解各名词关系：

3.Spring-Batch架构组件分类：
Application(应用层):包含开发者应用Spring-batch编写的所有批处理作业和自定义代码;
Batch Core(核心层):包含加载和控制批处理作业所必需的核心类，它包含了Job,Step,JobLauncher的实现;
Infrastructure(基础架构层)：基础架构层包含了Reader(ItemReader),Writer(ItemWriter),Services可以被应用层和核心层使用;

4.各层关系图解：

二．创建一个简单的Spring-batch项目
1.创建spring-batch工程，将其导IDE中

2.创建一个简单的Job
（1）创建一个Configuration包；

（2）创建一个Configuration类：需加上@Configuration;@EnableBatchProcessing;

（3）注入使用的依赖@Autowired:JobBuilderFactory;StepbuilderFactory;

（4）类展示：

package com.dhcc.batch.batchDemo.config;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
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.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
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;
import org.springframework.context.annotation.Primary;

@Configuration 
@EnableBatchProcessing
public class JobConfiguration {
    @Autowired
    private JobBuilderFactory jobBuilderFactory;
    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Primary
    @Bean
    public Job helloWord() {
        return jobBuilderFactory.get("helloWordJob").start(step1()).build();

    }

    JobLauncher
    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1").tasklet(new Tasklet() {

            @Override
            public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
                System.out.println("Hello Spring Batch....");
                return RepeatStatus.FINISHED;
            }
        }).build();

    }
}

（5）打开BatchDemoApplication启动服务器异常信息：

解决办法：分析spring-batch运行时需要数据库支持，而我们没有连接任何的数据库，故我们以spring中的内存数据库H2为例，进行配置，如下：

<!-- 内存数据库h3 -->
        <dependency>
            <groupId>com.h3database</groupId>
            <artifactId>h3</artifactId>
        </dependency>

添加完成，我们继续启动项目，查看控制台：

项目运行成功，我们看见控制台输出信息，我们成功创建了Job以及step，并打印出hello word Batch...
三．开发环境的搭建
前提：在MySQL数据库中创建我们需要的数据库，我创建的数据库名为springbatch;

1.我们以MySQL数据库为例，首先先加入Jdbc以及mysql数据库的一些依赖（记得注释掉H2内存数据库依赖）;

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

2.在application.properties下添加配置信息;

spring.datasource.url=jdbc:mysql://localhost:3306/springbatch?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
spring.datasource.username=root
spring.datasource.password=qitao1996
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.schema=classpath:/org/springframework/batch/core/schema-mysql.sql

spring.batch.initialize-schema=always

配置完成后，我们再次启动我们的项目，观察控制台：

可以看见项目运行成功，现在我们在进入数据库中观察我们的springbatch数据库结果我们发现运行之前没有任何表的数据库现在出现了如下表：

四．总结SpringBatch中的重要概念（经过二，三的学习对一进一步认识）
1.Job:是一个接口，接口中定义了一个作业是怎么样执行的;JobInstance是为Job的一次运行，我们可以将其理解为Job的一个实例；JobExceution是JobInstace的每一次执行，他会记录状态，根据状态尝试执行，未执行成功，下一次继续执行
2.JobInstance：是job的一次执行，一个JobInstance可重复执行，如果上一次执行失败下次执行的时候还会重新执行上次失败的job，每一次执行就是一个JobExceution
3.JobParameters:作为参数可以用来启动Job,并且可以用来标识不同的Job，运行时提供给JobInstance,jonExceution根据状态和参数决定下一次是否继续执行
4.JobExceution：每一次尝试执行一个Job的时候，我们就可以将其称为一个JobExceution，这个执行的结果可以为成功，也可以为失败，例如一个JobInstance执行失败了，下一次执行他传入的参数是上次执行的时间，他将会继续执行，这样始终执行的是一个JobInstance，而产生了两个JobExceution
图例：

5.Step:主要分为两块
（1）Tasklet：接口他其中包含了一个唯一的方法execute();
（2）Chunk-based:一个一个处理Step中如下模块：
·itemReader：数据输入input：对于一个Step而言，每次读取一个条目；
·itemProcessor:数据处理processing
·ItemWriter：数据输出output：对于一个Step而言，每次根据设定输出批量一个条目；
6.StepExecution:一个Step的每一次尝试执行，都会创建一个StepExection,在一个Step实际开始执行的时候创建（如下图解）

7.ExecutionContext:执行上下文，代表的是一个key-value键值对的集合，可以被Spring框架进行在持久化管理，能够是开发人员存储持久化状态，每一个JobExecution以及每一个StepExecution的执行都会对应一个执行上下文（ExecutionContext）;对于StepExecution在每一次提交点时就会保存一下执行上下文，而对于Job是在每一个StepExecution执行之间进行保存，例如，我们从Step1换到Step2是就会保存;
8.JobRepository:此条不再重复解释
9.JobLauncher：接口，用于启动和加载Job，根据传入的参数进行启动,返回Job一次执行的情况，如下接口方法;

public JobExecution run(Job job, JobParameters jobParameters) throws JobExecutionAlreadyRunningException,
            JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException;

下面附完整pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.dhcc.batch</groupId>
    <artifactId>batchDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>batchDemo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 内存数据库h3 
        <dependency>
            <groupId>com.h3database</groupId>
            <artifactId>h3</artifactId>
        </dependency>
        -->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>