spring Batch实现数据库大数据量读写

查询数据库最大行数限制探究 查询数据库最大行数限制探究 1. 问题背景 最近,在对项目中的机构部门表的数据访问层代码进行单元测试时,甚是神奇地发现了这个指标——查询数据库最大行数限制。 首先,使用查询总行数语句查出该表的总行数为:10768。 SELECT count(1) FROM department_define; 单元测试: @Test public void test() { List<DepartmentDefinePO> departmentDefinePOList = baseDataMapper.li 阅读详情
spring Batch实现数据库大数据量读写

1. data-source-context.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.0.xsd  
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">  
  
    <!-- 1) USE ANNOTATIONS TO IDENTIFY AND WIRE SPRING BEANS. -->  
    <context:component-scan base-package="net.etongbao.vasp.ac" />  
      
    <!-- 2) DATASOURCE, TRANSACTION MANAGER AND JDBC TEMPLATE -->  
   
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
        destroy-method="close" abstract="false" scope="singleton">  
        <!-- oracle.jdbc.driver.oracleDriver -->  
        <property name="driverClass" value="oracle.jdbc.OracleDriver" />  
        <property name="jdbcUrl" value="jdbc:oracle:thin:@192.168.1.23:1521:orcl01" />  
        <property name="user" value="USR_DEV01" />  
        <property name="password" value="2AF0829C" />  
        <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="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  
      
    <tx:annotation-driven transaction-manager="transactionManager" />  
</beans>  


2. quart-zcontext.xml commit-interval="10000"每次批量数据的条数,数值越大效率越高,

可在此处添加事物处理,每次回滚数就是commit-interval数


<?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.0.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.0.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">  
  
    <import resource="data-source-context.xml"/>  
      
    <!--   JOB REPOSITORY - WE USE IN-MEMORY REPOSITORY FOR OUR EXAMPLE -->  
    <bean id="jobRepository"  
        class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">  
        <property name="transactionManager" ref="transactionManager" />  
    </bean>  
      
    <!-- batch config -->  
    <bean id="jobLauncher"  
        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">  
        <property name="jobRepository" ref="jobRepository" />  
    </bean>  
  
    <!--  FINALLY OUR JOB DEFINITION. THIS IS A 1 STEP JOB -->  
    <batch:job id="ledgerJob">  
        <batch:listeners>  
            <batch:listener ref="appJobExecutionListener" />  
        </batch:listeners>  
      <batch:step id="step1"> 
        <batch:tasklet transaction-manager="transactionManager">  
        <batch:tasklet>  
          <batch:listeners>  
              <batch:listener ref="itemFailureLoggerListener" />  
          </batch:listeners>  
          <batch:chunk reader="ledgerReader" writer="ledgerWriter"  commit-interval="10000" /> <!-- 1万条进行一次commit -->  
        </batch:tasklet>
        </batch:tasklet>  
     </batch:step>  
</batch:job>  
   
<!--  READER -->  
<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>  
   
<!-- Spring Batch Job同一个job instance,成功执行后是不允许重新执行的【失败后是否允许重跑,可通过配置Job的restartable参数来控制,默认是true】,如果需要重新执行,可以变通处理,  
    添加一个JobParameters构建类,以当前时间作为参数,保证其他参数相同的情况下却是不同的job instance -->  
<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" >    
    <!-- 这里不可以直接在属性jobDetail中引用taskJob,因为他要求的是一个jobDetail类型的对象,所以我们得通过MethodInvokingJobDetailFactoryBean来转一下 -->    
    <property name="jobDetail" >    
        <ref bean="ledgerJobDetail" />    
    </property>    
    <!--在每天下午18点到下午18:59期间的每1分钟触发  -->    
    <!--在每天上午10点40分准时触发  -->    
    <property name="cronExpression" >    
        <!-- <value>0 * 15 * * ?</value> -->  
        <value>0 45 10 * * ? * </value>   
    </property>    
         
</bean>    
       
<!-- 触发器工厂,将所有的定时任务都注入工厂-->    
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">    
    <!-- 添加触发器 -->    
    <property name="triggers">    
        <list>    
            <!-- 将上面定义的测试定时任务注入(可以定义多个定时任务,同时注入)-->    
            <ref local="ledgerCronTrigger" />    
        </list>    
    </property>    
</bean>    
<!-- 定时任务 结束 -->    
  /beans>    


3.定时调度job类 QuartzLedgerJob.java 

package net.etongbao.vasp.ac.quartz;


import java.util.Date;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.batch.core.Job;  
import org.springframework.batch.core.JobParametersBuilder;  
import org.springframework.batch.core.launch.JobLauncher;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
import org.springframework.util.StopWatch;  
  
/** 
 * 定时调度类 
 * @author Fu Wei 
 * 
 */  
  
@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 {  
        LOG.debug("start...");  
        StopWatch sw = new StopWatch();  
        sw.start();  
        /* 
         * Spring Batch Job同一个job instance,成功执行后是不允许重新执行的【失败后是否允许重跑, 
         * 可通过配置Job的restartable参数来控制,默认是true】,如果需要重新执行,可以变通处理, 
         * 添加一个JobParameters构建类,以当前时间作为参数,保证其他参数相同的情况下却是不同的job instance 
         */  
        jobParameterBulider.addDate("date", new Date());  
        jobLauncher.run(ledgerJob, jobParameterBulider.toJobParameters());  
        sw.stop();  
        LOG.debug("Time elapsed:{},Execute quartz ledgerJob:{}", sw.prettyPrint(), ++counter);  
    }  
}  

4.程序启动类 StartQuartz.java 

package net.etongbao.vasp.ac.quartz;


import java.io.FileNotFoundException;  
  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
  
/** 
 * 启动定时调度 
 * @author Fu Wei 
 * 
 */  
public class StartQuartz {  
  
    public static void main(String[] args) throws FileNotFoundException {  
  
        new ClassPathXmlApplicationContext("/net/etongbao/vasp/ac/resources/quartz-context.xml");  
    }  
}  


5. pojo类  Ledger.java


package net.etongbao.vasp.ac.pojo;  
  
import java.io.Serializable;  
import java.util.Date;  
  
public class Ledger implements Serializable {  
  
    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;  
  
    public Ledger() {  
        super();  
    }  
  
    public Ledger(int id, Date receiptDate, String memberName, String checkNumber, Date checkDate, String paymentType,  
            double depositAmount, double paymentAmount, String comments) {  
        super();  
        this.id = id;  
        this.receiptDate = receiptDate;  
        this.memberName = memberName;  
        this.checkNumber = checkNumber;  
        this.checkDate = checkDate;  
        this.paymentType = paymentType;  
        this.depositAmount = depositAmount;  
        this.paymentAmount = paymentAmount;  
        this.comments = comments;  
    }  
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public Date getReceiptDate() {  
        return receiptDate;  
    }  
  
    public void setReceiptDate(Date receiptDate) {  
        this.receiptDate = receiptDate;  
    }  
  
    public String getMemberName() {  
        return memberName;  
    }  
  
    public void setMemberName(String memberName) {  
        this.memberName = memberName;  
    }  
  
    public String getCheckNumber() {  
        return checkNumber;  
    }  
  
    public void setCheckNumber(String checkNumber) {  
        this.checkNumber = checkNumber;  
    }  
  
    public Date getCheckDate() {  
        return checkDate;  
    }  
  
    public void setCheckDate(Date checkDate) {  
        this.checkDate = checkDate;  
    }  
    public String getPaymentType() {  
        return paymentType;  
    }  
  
    public void setPaymentType(String paymentType) {  
        this.paymentType = paymentType;  
    }  
  
    public double getDepositAmount() {  
        return depositAmount;  
    }  
  
    public void setDepositAmount(double depositAmount) {  
        this.depositAmount = depositAmount;  
    }  
  
    public double getPaymentAmount() {  
        return paymentAmount;  
    }  
  
    public void setPaymentAmount(double paymentAmount) {  
        this.paymentAmount = paymentAmount;  
    }  
  
    public String getComments() {  
        return comments;  
    }  
  
    public void setComments(String comments) {  
        this.comments = comments;  
    }  
}  


6. LedgerDaoImpl.java

    package net.etongbao.vasp.ac.dao.impl;


import java.sql.PreparedStatement;  
import java.sql.SQLException;  
import net.etongbao.vasp.ac.dao.LedgerDao;  
import net.etongbao.vasp.ac.pojo.Ledger;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.jdbc.core.PreparedStatementSetter;  
import org.springframework.stereotype.Repository;  
  
/** 
 * ledger数据操作类 
 *  
 * @author Fu Wei 
 *  
 */  
  
@Repository  
public class LedgerDaoImpl implements LedgerDao {  
  
    private static final String SAVE_SQL = "insert into ledger_temp (rcv_dt, mbr_nm, chk_nbr, chk_dt, pymt_typ, dpst_amt, pymt_amt, 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());  
            }  
        });  
    }   
}  

7. 接口 LedgerDao .java


package net.etongbao.vasp.ac.dao;  
  
import net.etongbao.vasp.ac.pojo.Ledger;  
  
public interface LedgerDao {  
    public void save(final Ledger item) ;  
}  

 8. JdbcTemplete 需要的LedgerRowMapper.java

     package net.etongbao.vasp.ac.batch.writer;


import java.sql.ResultSet;  
import java.sql.SQLException;  
  
import net.etongbao.vasp.ac.pojo.Ledger;  
  
import org.springframework.jdbc.core.RowMapper;  
import org.springframework.stereotype.Component;  
   
/** 
 * ledger行的映射类 
 * @author Administrator 
 * 
 */  
@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("rcv_dt"));  
        ledger.setMemberName(rs.getString("mbr_nm"));  
        ledger.setCheckNumber(rs.getString("chk_nbr"));  
        ledger.setCheckDate(rs.getDate("chk_dt"));  
        ledger.setPaymentType(rs.getString("pymt_typ"));  
        ledger.setDepositAmount(rs.getDouble("dpst_amt"));  
        ledger.setPaymentAmount(rs.getDouble("pymt_amt"));  
        ledger.setComments(rs.getString("comments"));  
        return ledger;  
    }  
}  


9.关键类LedgerWriter.java,写入数据,负责数据的添加 


package net.etongbao.vasp.ac.batch.writer;  
  
import java.util.List;  
  
import net.etongbao.vasp.ac.dao.LedgerDao;  
import net.etongbao.vasp.ac.pojo.Ledger;  
  
import org.springframework.batch.item.ItemWriter;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
/** 
 * ledger写入数据 
 *  
 * @author Fu Wei 
 *  
 */  
@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);  
        }  
    }    
}  


classPath:<?xml version="1.0" encoding="UTF-8"?>


<classpath>  
    <classpathentry kind="src" path="src"/>  
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jrockit-jdk1.6.0_24-R28.1.3-4.0.1"/>  
    <classpathentry kind="lib" path="lib/aopalliance-1.0.jar"/>  
    <classpathentry kind="lib" path="lib/c3p0-0.9.1.2.jar"/>  
    <classpathentry kind="lib" path="lib/commons-collections-3.2.1.jar"/>  
    <classpathentry kind="lib" path="lib/commons-lang-2.3.jar"/>  
    <classpathentry kind="lib" path="lib/commons-logging-1.1.1.jar"/>  
    <classpathentry kind="lib" path="lib/etb-log4j-1.2.16.jar"/>  
    <classpathentry kind="lib" path="lib/etb-slf4j-api-1.5.8.jar"/>  
    <classpathentry kind="lib" path="lib/etb-slf4j-log4j12-1.5.8.jar"/>  
    <classpathentry kind="lib" path="lib/ojdbc6.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.aop-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.asm-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.aspects-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.beans-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.context-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.context.support-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.core-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.expression-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.instrument-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.instrument.tomcat-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.jdbc-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.jms-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.orm-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.oxm-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.test-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/org.springframework.transaction-3.0.5.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/quartz-all-1.6.5.jar"/>  
    <classpathentry kind="lib" path="lib/spring-batch-core-2.1.6.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/spring-batch-infrastructure-2.1.6.RELEASE.jar"/>  
    <classpathentry kind="lib" path="lib/spring-batch-test-2.1.6.RELEASE.jar"/>  
    <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>  
    <classpathentry kind="output" path="bin"/>  
</classpath>  

 总结: 测试数据8万多条,响应时间3分多钟。

 

关键在于quartz-context.xml中


<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>

 

负责读取数据在程序执行时一次性抓取全部数据后在批量的交给LedgerWriter进行写操作。当然也可以使用分页读取JdbcPagingItemReader,但要分页数量与写入数量要大写相

同,还可以对分页出来的数据进行添加悲观锁LedgerWriter.java 负责写入数据,每次写入1000条。








Spring Batch 专题系列(七):Spring Batch 与数据库集成 在上一篇文章中,我们学习了 Spring Batch 的并行处理机制(多线程 Step、分区、并行 Job)和性能优化技巧,掌握了如何处理海量数据。在批处理任务中,数据库操作是最常见的场景之一,例如从源表读取数据,经过转换后写入目标表(ETL)、批量更新记录或生成报表。本文详细讲解了 Spring Batch 与数据库的集成,包括 JDBC、JPA 和 MyBatis 的读写方式,以及事务管理和性能优化实践。A:JDBC 适合高性能 ETL,JPA 适合复杂实体关系,MyBatis 介于两者,灵活性高。 阅读详情

相关推荐

Spring Batch从入门到精通的知识介绍

Spring Batch 是一个轻量级的、全面的批处理框架,用于开发企业级的批处理应用程序。它构建在经典的 Java EE 核心技术之上,同时利用了 Spring Framework 提供的灵活性和可扩展性。

技术探秘者的博客 1503

Spring Batch之读数据库——JdbcCursorItemReader(三十五)

一、JdbcCursorItemReader结构及关键属性 JdbcCursorItemReader将数据库记录转换为Java对象时主要有两步工作:首先根据PreparedStatement从数据库中获取结果集ResultSet;然后使用RowMapper将结果集ResultSet转换为Java对象。 二、关键接口、类和关键属性 1.JdbcCursorItemReader关键接口、类 关键类 说明 DataSource 提供读取数据库的数据源信息 PreparedState

qq_21370419的博客 4912

断点回归(regression discontinuity design)学习笔记

本篇博文主要是对断点回归的一些学习和总结~ 学习材料如下: 1 断点回归设计RDD分类与操作案例 2 RDD断点回归, Stata程序百科全书式的宝典 3 断点回归设计的前沿研究现状, RDD 4 让“跳跃”更有意义:断点回归设计(RDD) 5 Stata: 断点回归 (RDD) 教程 6 怎么用通俗的语言解释断点回归?它与DID的区别是什么 7 Watering Down Environmental Regulation in China,Guojun He, Shaoda Wang, Bing Zhan

Claire_chen_jia的博客 9万+

大数据批处理框架Spring Batch

如今微服务架构讨论的如火如荼。但在企业架构里除了大量的OLTP交易外,还存在海量的批处理交易。在诸如银行的金融机构中,每天有3-4万笔的批处理作业需要处理。针对OLTP,业界有大量的开源框架、优秀的架构设计给予支撑;但批处理领域的框架确凤毛麟角。是时候和我们一起来了解下批处理的世界哪些优秀的框架和设计了,今天我将以Spring Batch为例,和大家一起探秘批处理的世界。 初识批处理

java、c++、机器学习方向King 1988

CODESYS EtherCAT通讯断了怎么办?手把手教你用ST语言写状态监测程序(附完整代码)

本文详细解析了CODESYS平台下EtherCAT通讯中断的故障排查与恢复方法,通过ST语言编写状态监测程序实现链路监测、故障隔离和伺服恢复。文章包含完整代码示例,帮助工程师快速诊断EtherCAT网络问题,提升工业自动化设备的运行稳定性。

weixin_30919571的博客 209

2023东华大学OJ机试题22-70

东华大学计算机考研复试机试22 约瑟夫环223、整除的尾数24、回文质数25、汽水瓶26、阶乘最后的非0位27、算菜价28、 水果价格29、求奇数的乘积30、求最晚和最早日期31、素数32、计算e33 数字之和34 繁殖问题35 奇妙的数字36 整除的尾数37 黑色星期五38 树39 约瑟夫环40 最大与最小41 环42 求数列项43 最高频率44 三艘船45 回文数46 特殊四位数47 最大值48 数列149 修理牛棚50 按要求输出序列51 部落人乘法52 序列53 双重回文数54 等差数列55 人见人

m0_49263811的博客 2600

spring batch mysql_Spring批处理 - JdbcCursorItemReader使用大型MySQL表抛出OutOfMemoryError

我正在编写一个使用Spring Batch处理来自MySQL数据库表的7,637,064行的程序。我已经用较小的表获得成功,但当JdbcCursorItemReader试图打开游标时,此表中的大量行会导致OutOfMemoryError异常。Spring批处理 - JdbcCursorItemReader使用大型MySQL表抛出OutOfMemoryError我可以通过抛出一个更大的Xmx来解决这...

weixin_26820427的博客 620

什么是Merkle树?用“文件柜”类比理解区块链的核心技术

Merkle树是一种用于区块链的数据结构,像一个高效的“文件柜”,用于存储和验证大量交易数据。比特币通过Merkle树将交易哈希组织成树状结构,层层汇总,最终生成一个唯一的根哈希,存储在区块头中。这种设计大幅减少数据存储和验证成本,支持快速校验交易的完整性和存在性。Merkle树通过密码学保证数据不可篡改,广泛应用于比特币、区块链及其他分布式系统。它的优势在于高效、轻量和安全,尤其适合轻节点验证和数据同步。理解Merkle树就像掌握区块链的“索引秘籍”,是Web3世界的关键技术。

在路上的专栏 1193

Spring Batch(6)——数据库批数据读写

因此当数据写入与整个Step绑定为事物时还需要实现一个控制过程是:在写入数据的过程中出现异常时要擦除本次事物已经写入的数据,这样才能和整个Step的状态保持一致。,因为数据库的各种链接池本身就保证了链接->写入->释放的高效执行,也不存在向队尾添加数据的问题。Spring Batch为不同类型的文件的写入提供了多个实现类,但并没有为数据库的写入提供任何实现类,而是交由开发者自己去实现接口。因此,对于数据库的写入操作只要按照常规的批量数据写入的方式即可,开发者使用任何工具都可以完成这个过程。

justlpf的专栏 2206

数字孪生在智慧医疗中的5个创新应用:从手术模拟到个性化治疗

数字孪生技术通过创建患者或医疗流程的动态虚拟映射,正在深刻变革智慧医疗。本文重点剖析了其在个性化治疗、手术模拟与导航、药物研发、医院管理优化及慢性病管理五大核心场景的创新应用,展现了如何利用智能映射与数据融合,为精准医疗和高效决策提供强大支持。

weixin_29189003的博客 445

东方财富网股票API逆向分析:手把手教你破解动态参数(2024最新版)

本文详细解析了2024年东方财富网股票API的动态参数生成机制,包括回调函数、身份验证和时效控制参数的逆向工程方法。通过实战代码演示,帮助开发者破解动态参数,实现高效稳定的股票数据爬取,适用于金融数据分析和量化交易场景。

weixin_29091105的博客 1030

Java后台框架篇--spring Batch实现数据库大数据量读写

1. data-source-context.xml   Xml代码   xml version="1.0" encoding="UTF-8"?>   beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema

非淡泊无以明志,非宁静无以致远 2409

信号编辑软件ZX/SignalEditing

信号编辑软件ZX/SignalEditing

weixin_45661395的博客 968

Spring Batch 批处理框架

一、 介绍Spring Batch能够支持简单的、复杂的和大数据量的批处理作业,是一个批处理应用框架,不是调度框架,但需要和调度框架(Quartz, Tivoli, Control-M, Cron等)合作来构建完成批处理任务。整体架构如下: 二、 基本概念 Job: 作业, 由多个 Step 组成,封装整个批处理操作, 是 Batch 操作的基础单元; Job Instance: 作业实例,每次作

不影响全局 3777

为什么我的OpenClaw安装后无法启动?Gateway服务故障排查全攻略

OpenClaw是一款功能强大的自动化工具,但其安装和运行依赖于多个服务组件,其中Gateway服务是核心组件之一。如果Gateway服务无法启动,整个OpenClaw系统将无法正常运行。本文将详细介绍OpenClaw安装后无法启动的常见原因及故障排查方法,帮助你快速定位并解决问题。

一键难忘的博客 4634

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Spring Batch 大数据量处理实战:从入门到精通

别叫我大神,叫我 Alex 就好。处理百万级数据不用愁,Spring Batch 让批处理变得优雅而高效。

alex_goden的博客 4244

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

关于 Spring Batch 的详细解析及其同类框架的对比分析,以及如何自己设计一个java批处理框架(类似spring batch)的步骤

关于 Spring Batch 的详细解析及其同类框架的对比分析

爱的叹息的专栏 2030

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

深入解析Spring Batch:企业级批处理框架的技术之旅

Spring Batch是一个开源的、轻量级的批处理框架,它基于Spring框架构建,继承了Spring的诸多优点,如依赖注入、面向切面编程等。Spring Batch旨在简化批处理应用程序的开发,提供了一套丰富的功能来支持事务管理、作业调度、异常处理、日志记录等。Spring Batch是一个完善的批处理框架,旨在帮助企业建立健壮、高效的批处理应用。它是Spring的一个子项目,使用Java语言并基于Spring框架为基础开发,使得已经使用Spring框架的开发者或者企业更容易访问和利用企业服务。

码到三十五 2万+

Spring Batch 批处理框架优化实践,效率嘎嘎高!

一、Spring Batch简介1 框架概述2 核心概念和组件二、批处理优化实践4.1 使用Spring Boot Actuator进行监控4.2 使用管理控制台来监控3.1 批处理启动前校验3.2 读写校验2.1 多进程处理2.2 多线程处理1.1 分页处理数据1.2 使用读写缓存1.3 行级别写操作1 减少读写次数2 并发处理任务3 提高数据校验准确性4 监控批处理任务三、实践示例3.1 修改...

Java知音 1335

Spring Batch零基础入门:第一个批处理程序

Spring Batch是Spring生态中的一个轻量级批处理框架,主要用于处理大量数据的读取、处理和写入。它的核心思想是将批处理任务分解为一个个独立的步骤,每个步骤由读取、处理和写入三个部分组成。

CyanWave34的博客 1043
上一篇: Java中的日志——Java.util.logging、log4j、commons-logging
下一篇: spring batch教程 之 配置并运行Job
回头等终点
博客等级 码龄10年 29粉丝 17原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值