springbatch操作DB

最新推荐文章于 2025-04-17 07:38:06 发布
转载 最新推荐文章于 2025-04-17 07:38:06 发布 · 172 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/liguangsunls/p/7300199.html
文章标签：

#java #数据库

本文介绍如何使用Spring Batch框架实现从一个数据库表中读取数据，并批量插入到另一个表中的过程。涉及Spring Batch的核心配置、定时任务设置、异常处理及日志监听等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、需求分析

使用Spring Batch对DB进行读写操作: 从一个表中读取数据, 然后批量的插入另外一张表中.


二、代码实现

1. 代码结构图:


2. applicationContext.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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"> <!-- 配置spring扫描范围 --> <context:component-scan base-package="com.zdp" /> <!-- 配置数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" abstract="false" scope="singleton"> <property name="driverClass" value="org.gjt.mm.mysql.Driver" /> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?

useUnicode=true&characterEncoding=UTF-8" /> <property name="user" value="root" /> <property name="password" value="root" /> <property name="checkoutTimeout" value="30000" /> <property name="maxIdleTime" value="120" /> <property name="maxPoolSize" value="100" /> <property name="minPoolSize" value="2" /> <property name="initialPoolSize" value="2" /> <property name="maxStatements" value="0" /> <property name="maxStatementsPerConnection" value="0" /> <property name="idleConnectionTestPeriod" value="30" /> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource" /> </bean> <bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"> <property name="transactionManager" ref="transactionManager" /> </bean> <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher"> <property name="jobRepository" ref="jobRepository" /> </bean> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean> <tx:annotation-driven transaction-manager="transactionManager" /> </beans>

base-package: 扫描spring注解

jobLauncher: 启动Job

jobRepository: 为Job提供持久化操作

transactionManager: 提供事务管理操作


3. springBatch.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:batch="http://www.springframework.org/schema/batch"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans	
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/batch 
	http://www.springframework.org/schema/batch/spring-batch-2.1.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
	
	<!-- 引入spring核心配置文件 -->
	<import resource="applicationContext.xml"/>

	<batch:job id="ledgerJob">
		<!-- 监听job运行状态 -->
		<batch:listeners>
			<batch:listener ref="appJobExecutionListener" />
		</batch:listeners>
		<batch:step id="step">
			<!-- 加入事务控制 -->
			<batch:tasklet transaction-manager="transactionManager">
				<batch:listeners>
					<batch:listener ref="itemFailureLoggerListener" />
				</batch:listeners>
				<!-- commit-interval: 批量提交的条数; skip-limit: 指同意跳过记录数 -->
				<batch:chunk reader="ledgerReader" writer="ledgerWriter" commit-interval="1000" skip-limit="1000">
					<batch:skippable-exception-classes>
						<batch:include class="java.lang.Exception"/> <!-- 出现exception或其子类, Job仍然会往后运行 -->
						<batch:exclude class="java.io.FileNotFoundException"/> <!-- 出现这个异常, Job会立马停止 -->
					</batch:skippable-exception-classes>
				</batch:chunk> 
			</batch:tasklet>
		</batch:step>
	</batch:job>
	 
	<!-- 从ledger表读取数据 -->
	<bean id="ledgerReader" class="org.springframework.batch.item.database.JdbcCursorItemReader">
		<property name="dataSource" ref="dataSource" />
		<property name="sql" value="select * from ledger" /> 
		<property name="rowMapper" ref="ledgerRowMapper" />
	</bean>
	 
	<bean id="jobParameterBulider" class="org.springframework.batch.core.JobParametersBuilder" />
	
	<!-- 定时任务開始 -->  
	<bean id="ledgerJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
		<property name="targetObject">  
			<!-- 定时运行类 -->  
			<ref bean="quartzLedgerJob" />  
		</property>  
		<property name="targetMethod">  
			<!-- 定时运行类的方法 -->  
			<value>execute</value>  
		</property>  
	</bean>  
  
	<bean id="ledgerCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >   
		<property name="jobDetail" >  
			<ref bean="ledgerJobDetail" />  
		</property>  
		<property name="cronExpression" > 
			<!-- 每天晚上22:30运行 --> 
			<value>0 30 22 ?

* *</value> </property> </bean> <!-- 触发器工厂。将全部的定时任务都注入工厂--> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <!-- 加入触发器 --> <property name="triggers"> <list> <!-- 将上面定义的測试定时任务注入（能够定义多个定时任务。同一时候注入）--> <ref local="ledgerCronTrigger" /> </list> </property> </bean> </beans>


4. AppJobExecutionListener.java 

/**
 * 监听job执行状态
 */
@Component("appJobExecutionListener")
public class AppJobExecutionListener implements JobExecutionListener {
	private final static Logger logger = Logger.getLogger(AppJobExecutionListener.class);

	public void afterJob(JobExecution jobExecution) {
		if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
			logger.info("Job completed: " + jobExecution.getJobId());
		} else if (jobExecution.getStatus() == BatchStatus.FAILED) {
			logger.info("Job failed: " + jobExecution.getJobId());
		}
	}

	public void beforeJob(JobExecution jobExecution) {
		if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
			logger.info("Job completed: " + jobExecution.getJobId());
		} else if (jobExecution.getStatus() == BatchStatus.FAILED) {
			logger.info("Job failed: " + jobExecution.getJobId());
		}
	}
}


5. ItemFailureLoggerListener.java 

/**
 * 检查是读出错还是写出错
 */
@Component("itemFailureLoggerListener")
public class ItemFailureLoggerListener extends ItemListenerSupport<Object, Object> {
	private final static Logger LOG = Logger.getLogger(ItemFailureLoggerListener.class);

	public void onReadError(Exception ex) {
		LOG.error("Encountered error on read", ex);
	}

	public void onWriteError(Exception ex, Object item) {
		LOG.error("Encountered error on write", ex);
	}

}

6. Ledger.java 

public class Ledger implements Serializable {
	private static final long serialVersionUID = 1L;
	private int id;
	private Date receiptDate;
	private String memberName;
	private String checkNumber;
	private Date checkDate;
	private String paymentType;
	private double depositAmount;
	private double paymentAmount;
	private String comments;

	// getter and setter
}

7. LedgerRowMapper.java 

/**
 * ledger行的映射类
 */
@SuppressWarnings("rawtypes")
@Component("ledgerRowMapper")
public class LedgerRowMapper implements RowMapper {
	public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
		Ledger ledger = new Ledger();
		ledger.setId(rs.getInt("ID"));
		ledger.setReceiptDate(rs.getDate("RECEIPT_DATE"));
		ledger.setMemberName(rs.getString("MEMBER_NAME"));
		ledger.setCheckNumber(rs.getString("MEMBER_NAME"));
		ledger.setCheckDate(rs.getDate("CHECK_DATE"));
		ledger.setPaymentType(rs.getString("PAYMENT_TYPE"));
		ledger.setDepositAmount(rs.getDouble("DEPOSIT_AMOUNT"));
		ledger.setPaymentAmount(rs.getDouble("PAYMENT_AMOUNT"));
		ledger.setComments(rs.getString("COMMENTS"));
		return ledger;
	}
}

8. LedgerDao.java 

public interface LedgerDao {
	public void save(final Ledger item) ;
}

9. LedgerDaoImpl.java
/**
 * ledger数据操作类
 */
@Repository
public class LedgerDaoImpl implements LedgerDao {

	private static final String SAVE_SQL = "INSERT INTO LEDGER_TEMP (RECEIPT_DATE, MEMBER_NAME, CHECK_NUMBER, CHECK_DATE, PAYMENT_TYPE, DEPOSIT_AMOUNT, PAYMENT_AMOUNT, COMMENTS) VALUES(?,?

,?

,?,?

,?,?

,?)"; @Autowired private JdbcTemplate jdbcTemplate; @Override public void save(final Ledger item) { jdbcTemplate.update(SAVE_SQL, new PreparedStatementSetter() { public void setValues(PreparedStatement stmt) throws SQLException { stmt.setDate(1, new java.sql.Date(item.getReceiptDate().getTime())); stmt.setString(2, item.getMemberName()); stmt.setString(3, item.getCheckNumber()); stmt.setDate(4, new java.sql.Date(item.getCheckDate().getTime())); stmt.setString(5, item.getPaymentType()); stmt.setDouble(6, item.getDepositAmount()); stmt.setDouble(7, item.getPaymentAmount()); stmt.setString(8, item.getComments()); } }); } }


10. LedgerWriter.java 

/**
 * ledger写入数据
 */
@Component("ledgerWriter")
public class LedgerWriter implements ItemWriter<Ledger> {

	@Autowired
	private LedgerDao ledgerDao;

	/**
	 * 写入数据
	 * @param ledgers
	 */
	public void write(List<? extends Ledger> ledgers) throws Exception {
		for (Ledger ledger : ledgers) {
			ledgerDao.save(ledger);
		}
	}

}

11. QuartzLedgerJob.java

/**
 * 定时调度类
 */
@Component("quartzLedgerJob")
public class QuartzLedgerJob {

	private static final Logger LOG = LoggerFactory.getLogger(QuartzLedgerJob.class);

	@Autowired
	private JobLauncher jobLauncher;

	@Autowired
	private Job ledgerJob;

	@Autowired
	JobParametersBuilder jobParameterBulider;

	private static long counter = 0l;
	
	/**
	 * 运行业务方法
	 * @throws Exception
	 */
	public void execute() throws Exception {
		/**
		 * Spring Batch Job同一个job instance，成功运行后是不同意又一次运行的, 
		 * 失败后是否同意重跑，可通过配置Job的restartable參数来控制，默认是true，假设须要又一次运行。能够变通处理，
		 * 加入一个JobParameters构建类,以当前时间作为參数，保证其它參数同样的情况下是不同的job instance
		 */
		LOG.debug("start...");
		StopWatch stopWatch = new StopWatch(); 
		stopWatch.start();
		jobParameterBulider.addDate("date", new Date());
		jobLauncher.run(ledgerJob, jobParameterBulider.toJobParameters());
		stopWatch.stop();
		LOG.debug("Time elapsed:{},Execute quartz ledgerJob:{}", stopWatch.prettyPrint(), ++counter);
	}
}


12. StartQuartz.java

/**
 * 启动定时调度
 * 需求描写叙述: 定时从表ledger读取数据, 然后批量写入表ledger_temp
 */
public class StartQuartz {
	public static void main(String[] args) throws FileNotFoundException {
		new ClassPathXmlApplicationContext("/com/zdp/resources/springBatch.xml");
	}
}

13. sql: 

create table ledger(
	ID int(10) not null AUTO_INCREMENT PRIMARY KEY,
	RECEIPT_DATE date,
	MEMBER_NAME varchar(10) ,
	CHECK_NUMBER varchar(10) ,
	CHECK_DATE date,
	PAYMENT_TYPE varchar(10) ,
	DEPOSIT_AMOUNT double(10,3),
	PAYMENT_AMOUNT double(10,3),
	COMMENTS varchar(100) 
);

create table ledger_temp(
	ID int(10) not null AUTO_INCREMENT PRIMARY KEY,
	RECEIPT_DATE date,
	MEMBER_NAME varchar(10) ,
	CHECK_NUMBER varchar(10) ,
	CHECK_DATE date,
	PAYMENT_TYPE varchar(10) ,
	DEPOSIT_AMOUNT double(10,3),
	PAYMENT_AMOUNT double(10,3),
	COMMENTS varchar(100) 
);



转载于:https://www.cnblogs.com/liguangsunls/p/7300199.html

Springboot 整合 spring batch 实现批处理 ，小白文实例讲解
默默不代表沉默
08-24 2万+
前言 概念词就不多说了，我简单地介绍下 ，spring batch 是一个 方便使用的 较健全的 批处理 框架。 为什么说是方便使用的，因为这是 基于spring的一个框架，接入简单、易理解、流程分明。 为什么说是较健全的， 因为它提供了往常我们在对大批量数据进行处理时需要考虑到的 日志跟踪、事务粒度调配、可控执行、失败机制、重试机制、数据读写等。 正文 那么回到文章，我们该篇文章将会带来给大家的是什么？（结合实例讲解那是当然的） 从实现的业务场景来说，有以下两个...
Spring Boot & Spring Batch 实现批处理
长沙老码农
01-18 3802
Spring Boot & Spring Batch 实现批处理 需求领域 自动，复杂地处理大量信息，无需用户交互即可最有效地进行处理。这些操作通常包括基于时间的事件(例如月末计算，通知或通信)。 定期应用非常大的数据集(例如，保险利益确定或费率调整)重复处理复杂的业务规则。 从内部和外部系统接收的信息的集成，通常需要格式化，验证和以事务方式进行的处理到记录系统中。批处理每天用于为企业处理数十亿笔事务 Spring Batch介绍 核心流程图如下： Spring Batch 是一个轻量级的，全
spring Batch实现数据库大数据量读写
03-26
NULL 博文链接：https://virusfu.iteye.com/blog/1150730
springbatch对数据库的读写操作
lyf_ldh的博客
08-04 1811
读操作： @Configuration public class ItemReadDbDemo { @Autowired private JobBuilderFactory jobBuilderFactory; @Autowired private StepBuilderFactory stepBuilderFactory; @Autowired ...
Spring Batch 写数据库教程
neweastsun的专栏
10-03 2510
Spring Batch 写数据库教程 上文我们学习如何读数据库，本文我们看如何通过Spring Batch写数据库。 1.需求及环境准备 1.1. 示例需求说明 需要实现把在线学习系统中的学生信息通过Srping job写入数据库，单个学生信息类如下：学生姓名、电子邮件、已购学习包。写数据库之前，我们需要提供输入数据组件。本例我们使用StudentDto对象，其包括单个学生信息： @Data p...
Spring Batch(6)——数据库批数据读写
menergy
07-23 2881
前序文章陆续介绍了批处理的基本概念，Job使用、Step控制、Item的结构以及扁平文件的读写。本文将接着前面的内容说明数据库如何进行批处理读写。 数据读取 数据库是绝大部分系统要用到的数据存储工具，因此针对数据库执行批量数据处理任务也是很常见的需求。数据的批量处理与常规业务开发不同，如果一次性读取百万条，对于任何系统而言肯定都是不可取的。为了解决这个问题Spring Batch提供了2套数据读取方案： 基于游标读取数据 基于分页读取数据 游标读取数据 对于有经验大数据工程师而言数据库游标的操作应
使用spring batch需要在数据库建立的几个表——建表语句
07-31
使用spring batch需要在数据库建立的几个表——建表语句（BATCH_JOB_INSTANCE、BATCH_JOB_EXECUTION、BATCH_JOB_EXECUTION_CONTEXT、`BATCH_JOB_EXECUTION_PARAMS` 、`BATCH_JOB_EXECUTION_SEQ` 、`BATCH_JOB_SEQ` 、`BATCH_STEP_EXECUTION` 、`BATCH_STEP_EXECUTION_CONTEXT` 、`BATCH_STEP_EXECUTION_SEQ` ）
Tutorialspoint AB 测试 OrientDB Spring Batch GitLab DBUtils 教程
05-20
例如，你可能学习如何使用OrientDB存储和查询复杂数据结构，使用Spring Batch来批量处理这些数据，同时借助GitLab进行版本控制和团队协作，最后用DBUtils来编写高效的数据库操作代码。这样的组合可以帮助开发者构建...
如何在Java中使用Spring Batch：全方位指南
weixin_46372265的博客
07-15 1411
在这个大数据时代，处理大量数据的需求变得越来越普遍。无论是数据迁移、ETL任务（Extract, Transform, Load）、报表生成，还是其他批处理任务，手动处理这些繁琐的数据不仅低效，而且容易出错。幸好，Spring Batch应运而生，它是一个专为处理大批量数据任务而设计的轻量级框架，能够帮助我们轻松应对各种批处理需求。今天，我将深入浅出地为大家讲解如何在Java中使用Spring Batch，通过详细的代码示例和丰富的技术细节，带你一步步掌握这个强大的工具。
Spring Batch 专题系列（八）：Spring Batch 高级主题：扩展与定制
最新发布
资深架构师分享：深入剖析软件架构，探讨云计算、微服务、大数据等前沿技术。分享实践经验，促进技术交流，共同构建卓越系统。
04-17 1054
ItemReader负责读取数据，自定义 Reader 可以适配非标准数据源，如 REST API、Kafka、文件系统等。负责数据转换或业务逻辑，自定义 Processor 可以实现复杂处理，如调用外部服务、数据校验等。ItemWriter负责写入数据，自定义 Writer 可以适配非标准目标，如文件、API、队列等。示例：记录 Step 执行时间@Override@Override配置@Bean.build();说明beforeStep记录开始时间。afterStep。
Spring Batch之Sample（游标方式读写DB数据表）（二）
XuanYuZuo的专栏
10-17 1101
上篇文章中我们已经实现了用游标方式读写DB数据表，上篇的itemReader中sql语句并没有条件的限制，只是将表中的所有的数据都查询出来，然后再保存，本篇文章我们主要介绍怎样通过给定字段的值查出相应的结果集。 项目结构如下： 与上篇文章不同的主要是batch.xml配置文件，其余的都一样，该配置文件的内容主要如下： <bean:beans xmlns="http://www.sp
Spring中的ApplicationContext
cgl_dong的博客
06-24 455
Spring中的ApplicationContext 1、ApplicationContext应用程序上下文 ApplicationContext是最常用的Spring ioc容器，他实现了很多接口： BeanFactory：Spring 管理 Bean 的顶层接口，我们可以认为他是一个简易版的 Spring 容器。 ApplicationEventPublisher：用于封装事件发布功能的接口，向事件监听器（Listener）发送事件消息。 ResourceLoader：Spring 加载资源的顶层接口
在spring batch中如何使用rowmapper
topdeveloperr的博客
04-25 1843
概述 在spring batch框架中提供了三个核心的概念，分别是reader和processor和writer，分别用于读取，处理和写数据。关于这部分更详细的内容可以参考博客：批处理框架spring batch介绍及使用。这里不再展开。本篇文章主要想记录的问题是使用spring batch时，对于读取到的数据我们应该怎样去处理的问题。 怎样去处理读取到的数据，这个问题本质上是由需求决定的。如...
Spring Batch示例: 读取CSV文件并写入MySQL数据库
weixin_33726318的博客
05-21 1206
Spring Batch示例: 读取CSV文件并写入MySQL数据库 GitHub版本: https://github.com/kimmking/SpringBatchReferenceCN/blob/master/01_introduction/Spring_Batch_MySQL.md 原文链接: Reading and wri...
Spring Batch之读数据库——JdbcCursorItemReader（三十五）
qq_21370419的博客
03-08 4664
一、JdbcCursorItemReader结构及关键属性 JdbcCursorItemReader将数据库记录转换为Java对象时主要有两步工作：首先根据PreparedStatement从数据库中获取结果集ResultSet；然后使用RowMapper将结果集ResultSet转换为Java对象。 二、关键接口、类和关键属性 1.JdbcCursorItemReader关键接口、类 关键类 说明 DataSource 提供读取数据库的数据源信息 PreparedState
Spring batch 之操作数据库
日常笔记
12-16 3564
common.xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.s
springboot中使用websocket_Spring Boot中使用JdbcTemplate访问数据库
weixin_39848007的博客
11-23 557
本文介绍在Spring Boot基础下配置数据源和通过JdbcTemplate编写数据访问的示例。数据源配置在我们访问数据库的时候，需要先配置一个数据源，下面分别介绍一下几种不同的数据库配置方式。首先，为了连接数据库需要引入jdbc支持，在pom.xml中引入如下配置：嵌入式数据库支持嵌入式数据库通常用于开发和测试环境，不推荐用于生产环境。Spring Boot提供自动配置的嵌入式数据库有H2、H...
Spring Batch(6) : ItemReader & ItemWriter
热门推荐
Spring , Hadoop, Spark , BI , ML
03-26 1万+
针对批处理，Spring Batch提供ItemReader、ItemProcessor、ItemWriter三个核心组件，类似ETL的三个步骤。5.1 ItemReaderItemReader支持从多种数据源读入数据，接口定义如下：public interface ItemReader<T> { T read() throws Exception, UnexpectedInputExcep
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值