Spring Batch 基于spring boot的Demo

最新推荐文章于 2024-08-27 09:14:32 发布
最新推荐文章于 2024-08-27 09:14:32 发布
阅读量4.5k 收藏 6
点赞数 1
分类专栏： spring 文章标签： spring boot batch job EnableBatchProcessing 多数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hello_junz/article/details/81874972
版权

本文主要介绍如何实现spring boot的batch架构搭建。

数据库有两个，一个是spring batch需要的底层数据库，主要用于记录job的执行相关数据；另一个是自己的业务数据库，主要用于Demo job抓取数据、写入等。

1. maven的jar依赖配置pom.xml (片段)

 <parent>
       <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
    </parent>
	<properties>
	    <jdk.version>1.8</jdk.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-excel</artifactId>
            <version>0.5.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.11</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.11</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
		<dependency>
			<groupId>org.postgresql</groupId>
			<artifactId>postgresql</artifactId>
			<version>42.1.1</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jersey.media</groupId>
			<artifactId>jersey-media-json-jackson</artifactId>
			<version>2.12</version>
		</dependency>
		<dependency>
		    <groupId>com.zaxxer</groupId>
		    <artifactId>HikariCP</artifactId>
		    <version>3.1.0</version>
		</dependency>
	</dependencies>
   <build>
        <finalName>my-job-master</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18</version>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

2.项目包结构

conf包：下主要是batch job数据源配置、业务数据源配置及batch配置

core包：job启动相关类

job包：实现自己job的地方

3. spring boot入口文件

@SpringBootApplication
@EnableBatchProcessing
public class ApJobMasterApplication {


	public static void main(String[] args) {
		SpringApplication.run(ApJobMasterApplication.class, args);
	}
}

4. Batch配置

@Configuration
@EnableBatchProcessing
public class BatchConfig{

	@Bean
    public JobRepository jobRepository(@Qualifier("batchDataSource")DataSource dataSource, @Qualifier("batchTransactionManager")PlatformTransactionManager transactionManager) throws Exception{

        JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
        jobRepositoryFactoryBean.setDataSource(dataSource);
        jobRepositoryFactoryBean.setTransactionManager(transactionManager);
        jobRepositoryFactoryBean.setDatabaseType(DatabaseType.POSTGRES.name());

        return jobRepositoryFactoryBean.getObject();
    }
	
	@Bean
	public SimpleJobLauncher jobLauncher(@Qualifier("batchDataSource")DataSource dataSource, @Qualifier("batchTransactionManager")PlatformTransactionManager transactionManager) throws Exception{

        SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
        jobLauncher.setJobRepository(this.jobRepository(dataSource, transactionManager));

        return jobLauncher;
    }
	
	@Bean
    public SimpleJobExecutionListener myJobListener(){
        return new SimpleJobExecutionListener();
    }
}

5. Batch需要的数据源配置

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.thingple.dao.batch",entityManagerFactoryRef = "batchEntityManagerFactory",transactionManagerRef="batchTransactionManager")
public class SpringBatchDataSourceConfig {

	@Bean(name="batchDataSourceConf")
	@ConfigurationProperties("spring.batch.datasource")
	public DataSourceProperties batchtDataSourceProperties() {
	    return new DataSourceProperties();
	}

	@Bean(name="batchDataSource")
	@ConfigurationProperties("spring.batch.datasource")
	public DataSource getBatchDataSource() {
	    return batchtDataSourceProperties().initializeDataSourceBuilder().type(com.zaxxer.hikari.HikariDataSource.class).build();
	}
	
	@Bean(name="batchEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean apTruckEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(getBatchDataSource())
                .packages("com.thingple.entity.batch")
                .persistenceUnit("batchDs")
                .build();
    }

	@Bean(name="batchTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("batchEntityManagerFactory")EntityManagerFactory emf){
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }
}

6. 业务数据源配置

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.thingple.dao.ap",entityManagerFactoryRef = "apTruckEntityManagerFactory",transactionManagerRef="apTruckTransactionManager")
public class ApTruckDataSourceConfig {

	
	@Bean(name="apDataSourceConf")
	@ConfigurationProperties("ap.truck.datasource")
	@Primary
	public DataSourceProperties apTruckDataSourceProperties() {
	    return new DataSourceProperties();
	}

	@Bean(name="apDataSource")
	@ConfigurationProperties("ap.truck.datasource")
	@Primary
	public DataSource getApDataSource() {
	    return apTruckDataSourceProperties().initializeDataSourceBuilder().type(com.zaxxer.hikari.HikariDataSource.class).build();
	    //return apTruckDataSourceProperties().initializeDataSourceBuilder().build();
	}
	
    @Bean(name="apTruckEntityManagerFactory")
    @Primary
    public LocalContainerEntityManagerFactoryBean apTruckEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(getApDataSource())
                .packages("com.thingple.entity.ap")
                .persistenceUnit("apTruckDs")
                .build();
    }


    @Bean(name="apTruckTransactionManager")
    @Primary
    public PlatformTransactionManager transactionManager(@Qualifier("apTruckEntityManagerFactory")EntityManagerFactory emf){
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }

    
    @Bean(name="apJdbcTemplate")
    @Primary
    public JdbcTemplate jdbcTemplate(){
        return new JdbcTemplate(getApDataSource());
    }
    
    @Bean(name="apNameParameterJdbcTemplate")
    @Primary
    public NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
    	return new NamedParameterJdbcTemplate(getApDataSource());
    }

    @Bean(name="apTransactionTemplate")
    @Primary
    public TransactionTemplate transactionTemplate(@Qualifier("apTruckTransactionManager")PlatformTransactionManager platformTransactionManager){
        return new TransactionTemplate(platformTransactionManager);
    }
    
}

7.Demo Job配置

@Configuration
public class DemoJobConfig {
	
	private static final Logger LOGGER = LoggerFactory.getLogger(DemoJobConfig.class);

	@Bean(name="demoJobReader")
    @StepScope
    ItemReader<TruckDailyImportedData> demoJobReader(@Qualifier("apTruckEntityManagerFactory") EntityManagerFactory emf, 
    		@Value("#{jobParameters[startTime]}") String startTime,
    		@Value("#{jobParameters[endTime]}") String endTime) throws Exception {
    	LOGGER.info("[DemoJobConfig][demoJobReader]startTime={},endTime={}",startTime,endTime);
    	String query = "from TruckDailyImportedData d where d.startTime>=:startTime and endTime<=:endTime";
		Map<String, Object> params = new HashMap<>();
		params.put("startTime", DateUtil.getDayofBegin(DateUtil.parse(startTime)));
		params.put("endTime", DateUtil.getDayofEnd(DateUtil.parse(endTime)));
		
		JpaPagingItemReader<TruckDailyImportedData> reader = new JpaPagingItemReader<>();
		reader.setEntityManagerFactory(emf);
		
		reader.setPageSize(100);
		reader.setQueryString(query);
		reader.setParameterValues(params);
		reader.open(new ExecutionContext());
		reader.setTransacted(false);
        
        return reader;
    }
	
	@Bean(name="demoJobProcessor")
    @StepScope
    ItemProcessor<TruckDailyImportedData, TruckDailyImportedData> demoJobProcessor() {
        return new ItemProcessor<TruckDailyImportedData, TruckDailyImportedData>(){

			@Override
			public TruckDailyImportedData process(TruckDailyImportedData item) throws Exception {
				return item;
			}
        
        };
    }
	
	@Bean(name="demoJobWriter")
    @StepScope
    DemoJobDataWriter demoJobWriter() {
        return new DemoJobDataWriter();
    }
	
	
	@Bean(name="demoJobStep")
    Step demoJobStep(@Qualifier("demoJobReader")ItemReader<TruckDailyImportedData> demoJobReader,
    		        @Qualifier("demoJobProcessor")ItemProcessor<TruckDailyImportedData, TruckDailyImportedData> demoJobProcessor,
    		        @Qualifier("demoJobWriter")ItemWriter<? super TruckDailyImportedData> demoJobWriter,
    		        @Qualifier("apTruckTransactionManager") PlatformTransactionManager transactionManager,
                    StepBuilderFactory stepBuilderFactory) throws Exception {
        return stepBuilderFactory.get("demoJobStep")
                .<TruckDailyImportedData, TruckDailyImportedData>chunk(1)
                .reader(demoJobReader)
                .processor(demoJobProcessor)
                .writer(demoJobWriter)
                .chunk(50).transactionManager(transactionManager)
                .build();
    }
	 
	@Bean
    Job demoJob(JobBuilderFactory jobBuilderFactory,
                               @Qualifier("demoJobStep") Step demoJobStep,
                               SimpleJobExecutionListener listener) {
        return jobBuilderFactory.get("demoJob")
                .incrementer(new RunIdIncrementer())
                .flow(demoJobStep)
                .end()
                .listener(listener)
                .build();
    }
}

8. ItemWriter的实现类

public class DemoJobDataWriter implements ItemWriter<TruckDailyImportedData> {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoJobDataWriter.class);
    
    @Autowired
    private TruckMilesageLogDao truckMilesageLogDao;

	@Override
    public void write(List<? extends TruckDailyImportedData> items) throws Exception {
        LOGGER.info("Received the information of {} TruckDailyData", items.size());

        items.forEach(i -> LOGGER.debug("Received the information of a TruckDailyData: {}", i));
        if(CollectionUtils.isEmpty(items)) {
        	return;
        }
    
        for(TruckDailyImportedData item:items) {
        	insertOneItem(item);
        }
    }
    
//	@Transactional(value="apTruckTransactionManager",propagation=Propagation.REQUIRED)
    public void insertOneItem(TruckDailyImportedData item) {
    	TruckMilesageLog data = new TruckMilesageLog();
    	data.setTruckId(item.getLicensePlateNum());
    	data.setMilesage(item.getMilesage());
    	data.setOilWear(item.getOilWear());
    	data.setcTime(new Date());
    	
    	truckMilesageLogDao.save(data);
    }
}

9. JPA dao接口

@Repository
public interface TruckMilesageLogDao extends JpaRepository<TruckMilesageLog, Integer> {

}

10. 两个实体类（略）

11. spring properties文件

#Batch Configuration
#启动时要执行的Job，默认执行全部Job
spring.batch.job.names= 
#是否自动执行定义的Job，默认是
spring.batch.job.enabled=false
#是否初始化Spring Batch的数据库，默认为是
spring.batch.initializer.enabled=false 
spring.batch.schema=
#设置SpringBatch的数据库表的前缀
spring.batch.table-prefix=batch_

#Database Configuration
spring.batch.datasource.url=jdbc:postgresql://192.168.1.252:5432/job
spring.batch.datasource.driver-class-name=org.postgresql.Driver
spring.batch.datasource.username=xxx
spring.batch.datasource.password=xxx
spring.batch.datasource.test-on-borrow=true
spring.batch.datasource.remove-abandoned=true
spring.batch.datasource.validation-query=SELECT 1;
spring.batch.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.batch.datasource.hikari.minimum-idle=4
spring.batch.datasource.hikari.maximum-pool-size=15
spring.batch.datasource.hikari.auto-commit=true
spring.batch.datasource.hikari.idle-timeout=30000
spring.batch.datasource.hikari.pool-name=BatchHikariCP
spring.batch.datasource.hikari.max-lifetime=1800000
spring.batch.datasource.hikari.connection-timeout=30000
spring.batch.datasource.hikari.connection-test-query=SELECT 1
#database  pool config
# Number of ms to wait before throwing an exception if no connection is available.
#spring.datasource.tomcat.max-wait=10000
# Maximum number of active connections that can be allocated from this pool at the same time.
#spring.datasource.tomcat.max-active=3
# Validate the connection before borrowing it from the pool.
#spring.datasource.tomcat.test-on-borrow=true
# initial pool size
#spring.datasource.tomcat.initial-size=20

ap.truck.datasource.url=jdbc:postgresql://192.168.1.252:5432/ap_mgt
ap.truck.datasource.driver-class-name=org.postgresql.Driver
ap.truck.datasource.username=xxx
ap.truck.datasource.password=xxx
ap.truck.datasource.test-on-borrow=true
ap.truck.datasource.remove-abandoned=true
ap.truck.datasource.validation-query=SELECT 1;
ap.truck.datasource.hikari.minimum-idle=3
ap.truck.datasource.hikari.maximum-pool-size=15
ap.truck.datasource.hikari.auto-commit=true
ap.truck.datasource.hikari.idle-timeout=30000
ap.truck.datasource.hikari.pool-name=BatchHikariCP
ap.truck.datasource.hikari.max-lifetime=1800000
ap.truck.datasource.hikari.connection-timeout=30000
ap.truck.datasource.hikari.connection-test-query=SELECT 1



#=====================jpa config================================
#实体类维护数据库表结构的具体行为：update/create/create-drop/validate/none
spring.jpa.hibernate.ddl-auto=none
#打印sql语句
spring.jpa.show-sql=true

#=============jackson serialize config =========================
#格式化输出的json字符串
spring.jackson.serialization.indent_output=true

#=====================log config================================
#==================== 日志配合·标准  ============================  
logging.config=classpath:logback-job.xml

12 job数据库脚本

create database job with owner=postgres ENCODING='UTF-8';



-- Autogenerated: do not edit this file

CREATE TABLE BATCH_JOB_INSTANCE  (
	JOB_INSTANCE_ID BIGINT  NOT NULL PRIMARY KEY ,
	VERSION BIGINT ,
	JOB_NAME VARCHAR(100) NOT NULL,
	JOB_KEY VARCHAR(32) NOT NULL,
	constraint JOB_INST_UN unique (JOB_NAME, JOB_KEY)
) ;

CREATE TABLE BATCH_JOB_EXECUTION  (
	JOB_EXECUTION_ID BIGINT  NOT NULL PRIMARY KEY ,
	VERSION BIGINT  ,
	JOB_INSTANCE_ID BIGINT NOT NULL,
	CREATE_TIME TIMESTAMP NOT NULL,
	START_TIME TIMESTAMP DEFAULT NULL ,
	END_TIME TIMESTAMP DEFAULT NULL ,
	STATUS VARCHAR(10) ,
	EXIT_CODE VARCHAR(2500) ,
	EXIT_MESSAGE VARCHAR(2500) ,
	LAST_UPDATED TIMESTAMP,
	JOB_CONFIGURATION_LOCATION VARCHAR(2500) NULL,
	constraint JOB_INST_EXEC_FK foreign key (JOB_INSTANCE_ID)
	references BATCH_JOB_INSTANCE(JOB_INSTANCE_ID)
) ;

CREATE TABLE BATCH_JOB_EXECUTION_PARAMS  (
	JOB_EXECUTION_ID BIGINT NOT NULL ,
	TYPE_CD VARCHAR(6) NOT NULL ,
	KEY_NAME VARCHAR(100) NOT NULL ,
	STRING_VAL VARCHAR(250) ,
	DATE_VAL TIMESTAMP DEFAULT NULL ,
	LONG_VAL BIGINT ,
	DOUBLE_VAL DOUBLE PRECISION ,
	IDENTIFYING CHAR(1) NOT NULL ,
	constraint JOB_EXEC_PARAMS_FK foreign key (JOB_EXECUTION_ID)
	references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ;

CREATE TABLE BATCH_STEP_EXECUTION  (
	STEP_EXECUTION_ID BIGINT  NOT NULL PRIMARY KEY ,
	VERSION BIGINT NOT NULL,
	STEP_NAME VARCHAR(100) NOT NULL,
	JOB_EXECUTION_ID BIGINT NOT NULL,
	START_TIME TIMESTAMP NOT NULL ,
	END_TIME TIMESTAMP DEFAULT NULL ,
	STATUS VARCHAR(10) ,
	COMMIT_COUNT BIGINT ,
	READ_COUNT BIGINT ,
	FILTER_COUNT BIGINT ,
	WRITE_COUNT BIGINT ,
	READ_SKIP_COUNT BIGINT ,
	WRITE_SKIP_COUNT BIGINT ,
	PROCESS_SKIP_COUNT BIGINT ,
	ROLLBACK_COUNT BIGINT ,
	EXIT_CODE VARCHAR(2500) ,
	EXIT_MESSAGE VARCHAR(2500) ,
	LAST_UPDATED TIMESTAMP,
	constraint JOB_EXEC_STEP_FK foreign key (JOB_EXECUTION_ID)
	references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ;

CREATE TABLE BATCH_STEP_EXECUTION_CONTEXT  (
	STEP_EXECUTION_ID BIGINT NOT NULL PRIMARY KEY,
	SHORT_CONTEXT VARCHAR(2500) NOT NULL,
	SERIALIZED_CONTEXT TEXT ,
	constraint STEP_EXEC_CTX_FK foreign key (STEP_EXECUTION_ID)
	references BATCH_STEP_EXECUTION(STEP_EXECUTION_ID)
) ;

CREATE TABLE BATCH_JOB_EXECUTION_CONTEXT  (
	JOB_EXECUTION_ID BIGINT NOT NULL PRIMARY KEY,
	SHORT_CONTEXT VARCHAR(2500) NOT NULL,
	SERIALIZED_CONTEXT TEXT ,
	constraint JOB_EXEC_CTX_FK foreign key (JOB_EXECUTION_ID)
	references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ;

CREATE SEQUENCE BATCH_STEP_EXECUTION_SEQ MAXVALUE 9223372036854775807 NO CYCLE;
CREATE SEQUENCE BATCH_JOB_EXECUTION_SEQ MAXVALUE 9223372036854775807 NO CYCLE;
CREATE SEQUENCE BATCH_JOB_SEQ MAXVALUE 9223372036854775807 NO CYCLE;

至此，一个简单的batch框架就搭建好了。

Demo job中，读取业务数据库TruckDailyImportedData实体对应的表的数据，然后写入到TruckMilesageLog实体对应的表中。

其中有两个坑需要注意，否则报报错导致job无法正常读取、写入数据：

1 DemoJobConfig 类中的demoJobReader方法，必须显示调用read.open()，如上述示例中：

      reader.open(new ExecutionContext());

2 DemoJobConfig 类中的demoJobStep方法，要显示设置PlatformTransactionManager，如上述示例中：

     .transactionManager(transactionManager)

 

hello_junz
关注
专栏目录
springBoot+springBatch批量处理数据demo
02-29
最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
Spring-batch Demo.zip
07-16
Spring-batch Demo.zip Spring-batch Demo.zip Spring-batch Demo.zip
Spring Boot Demo 项目教程
最新发布
gitblog_00645的博客
08-27 876
Spring Boot Demo 项目教程 spring-boot-demoSpring Boot 教程、技术栈示例代码。在工作中的最佳实践，帮助快速上手运用到工作中。项目地址:https://gitcode.com/gh_mirrors/sprin/spring-boot-demo 项目介绍 spring-boot-demo 是一个用来深度学习并实战 Spring Boot 的项目。目前总共包...
spring batch demo
06-14
Spring Batch批处理框架demo，详细介绍java批处理框架spring batch demo
spring-batch-demo.rar
05-30
一个SpringBatch的入门案例，SpringBatch是spring体系下的一个轻量级的批处理框架，使用简单方便，是非常优秀的一个批处理框架。如果你的工作中涉及到了批处理作业，可以考虑使用SpringBatch框架，本案例有详细的注释说明，请查看。
Spring Boot集成Spring Batch快速入门Demo
HBLOG
07-20 1744
Spring Batch 是一个轻量级的开源框架，它提供了一种简单的方式来处理大量的数据。它基于Spring框架，提供了一套批处理框架，可以处理各种类型的批处理任务，如ETL、数据导入/导出、报表生成等。Spring Batch提供了一些重要的概念，如Job、Step、ItemReader、ItemProcessor、ItemWriter等，这些概念可以帮助我们构建可重用的批处理应用程序。
Spring Batch 基于spring boot的Demo-01
11-05
在springbatch每一个任务都有不同的step组成。每一个step 可以拆解为 读数据 ，处理数据，写入数据 3 个步骤。如果你的任务不涉及读，处理，写 这种特点，只是简单的任务处理 springbatch 也提供了 tasklet 来处理...
Spring Boot整合Spring Batch，实现批处理
03-06
首先，**Spring Boot** 是一种基于Spring框架的简化版启动器，它极大地减少了传统Spring应用的配置工作。通过自动配置和“起步依赖”（Starter Dependency），Spring Boot使得创建独立的、生产级别的Java应用变得...
基于Spring Batch向Elasticsearch批量导入数据示例
08-27
基于Spring Batch向Elasticsearch批量导入数据示例 本文介绍了基于Spring Batch向Elasticsearch批量导入数据示例，旨在解决大规模数据从数据库导入Elasticsearch时的效率问题。Spring Batch框架使用ItemReader分页...
Spring-batch Demo
06-20
Spring Batch流程介绍： 每个Batch都会包含一个Job。Job就像一个容器，这个容器里装了若干Step，Batch中实际干活的也就是这些Step，至于Step干什么活，无外乎读取数据，处理数据，然后将这些数据存储起来(IconvItemReader用来读取数据，IconvItemProcessor用来处理数据，IconvItemWriter用来写数据) 。JobLaunch用来启动Job，JobRepository是上述处理提供的一种持久化机制，它为JobLauncher，Job，和Step实例提供CRUD操作。 外部控制器调用JobLauncher启动一个Job，Job调用自己的Step去实现对数据的操作，Step处理完成后，再将处理结果一步步返回给上一层，这就是Batch处理实现的一个简单流程。
springbatch DEMO
09-14
springbatch 文件写入DB， 需要自己创建一个users表 /* SQLyog Professional v10.51 MySQL - 5.5.28-log ********************************************************************* */ /*!40101 SET NAMES utf8 */; create table `users` ( `id` int (6), `user_login` varchar (150), `user_pass` varchar (150), `age` int (6) ); insert into `users` (`id`, `user_login`, `user_pass`, `age`) values('1','123','13','13');
spring-batch-demos
06-07
关于 Spring 批量演示。 特征 管理工作 但关键任务流程需要更强大的方法。 保持作业状态以供重新执行、在作业失败时通过事务管理保持数据完整性以及保存过去作业执行的性能指标以进行趋势分析的能力，是您期望在企业批处理系统中使用的功能。 这些特性都包含在Spring Batch中，并且大部分都是默认开启的； 在您开发流程时，它们只需要对性能和要求进行最少的调整。 本地和远程并行化 批处理作业的规模以及对它们进行扩展的需求对于任何企业批处理解决方案都至关重要。 Spring Batch 提供了以多种不同方式处理此问题的能力。 来自一个简单的基于线程的实现，其中每个提交间隔都在线程池的自己的线程中进行处理； 并行运行全部步骤； 配置一个工作单元网格，这些工作单元通过分区从远程主节点获取工作单元； Spring Batch 提供了一系列不同的选项，包括并行块/步骤处理、远程块处理和分区。 标准化
[原创]Spring Batch 示例程序
11-25
SpringBatch 示例小程序源码(内含依赖的jar包) 本示例程序 使用 Spring 3 + Spring Batch 2.2.7
SpringBatchSample:Spring Batch 示例 4 书
07-12
SpringBatchSample Spring Batch Sample 4 book 本项目是图书《Spring Batch批处理框架》的配套源代码。
SpringBatch-Demo1
tiantiantbtb的博客
03-24 599
SpringBatch:就是将数据分批次进行处理的过程。比如：银行对账逻辑，跨系统数据同步等。Sping Batch 是一个轻量级的、完善的的批处理框架，旨在帮助企业建立健壮、高效的批处理应用。Spring Batch 是Spring的一个子项目，基于Spring框架为基础的开发的框架Spring Batch 提供大量可重用的组件，比如：日志，追踪，事务，任务作业统计，任务重启，跳过，重复，资源管理等。
spring batch demo 注解版
小白鼠丶
12-04 6476
pom.xml:<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/mave
springbatch实操Demo
qq_40250122的博客
05-15 609
/* * Copyright yangjunxiong 2021 Wicrenet, Inc. All rights reserved. */ package com.aegonthtf.fate.service.batch; import com.aegonthtf.fate.constant.BatchConvertEnum; import com.aegonthtf.fate.constant.CommonConstant; import com.aegonthtf.fate.dto.JobBe
深入理解Spring Batch
"Spring Batch in Action 是一本关于Spring Batch的书籍，旨在介绍和深入探讨Spring Batch框架。这本书适合想要理解和掌握Spring Batch的开发者，通过它能学习到如何在实际项目中进行批处理任务的开发与管理。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值