使用spring batch 连接oracle操作时，总是报出如下异常：

PreparedStatementCallback; SQL [INSERT into BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, JOB_KEY, VERSION) values (?, ?, ?, ?)]; ORA-08177: 无法连续访问此事务处理

原因： spring batch 默认是 ISOLATION_SERIALIZABLE

官方文档说明： The default is ISOLATION_SERIALIZABLE, which prevents accidental concurrent execution of the same job (ISOLATION_REPEATABLE_READ would work as well).

解决办法：

1. 查阅资料： http://stackoverflow.com/questions/22364432/spring-batch-ora-08177-cant-serialize-access-for-this-transaction-when-running 都说将oracle事务级别从 SERIALIZABLE 调整为 ISOLATION_READ_COMMITTED 就行了。的确是这样。

2.自己根据资料实现：

package cn.yong.zheng.config;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.launch.support.SimpleJobLauncher;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
 * @author zhengyong
@Configuration
@EnableBatchProcessing
public class CommonBatchConfiguration{
	private static final Logger logger = LoggerFactory.getLogger(CommonBatchConfiguration.class);
    @Bean
    public JobRepositoryFactoryBean jobRepositoryFactoryBean(DataSource dataSource,PlatformTransactionManager transactionManager){
    	JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
    	jobRepositoryFactoryBean.setTransactionManager(transactionManager);
    	jobRepositoryFactoryBean.setDataSource(dataSource);
    	jobRepositoryFactoryBean.setIsolationLevelForCreate("ISOLATION_READ_COMMITTED");
    	try {
    		jobRepositoryFactoryBean.afterPropertiesSet();
		} catch (Exception e) {
			logger.error("创建jobRepositoryFactoryBean异常：{}",e.getMessage());
    	return  jobRepositoryFactoryBean;
    @Bean
    public JobRepository jobRepository(JobRepositoryFactoryBean jobRepositoryFactoryBean){
    	JobRepository jobRepository = null;
		try {
			jobRepository = jobRepositoryFactoryBean.getObject();
		} catch (Exception e) {
			logger.error("创建jobRepository异常{}",e.getMessage());
    	return jobRepository;
    @Bean
    public SimpleJobLauncher  simpleJobLauncher(JobRepository jobRepository){
    	SimpleJobLauncher  simpleJobLauncher = new SimpleJobLauncher();
    	simpleJobLauncher.setJobRepository(jobRepository);
    	try {
			simpleJobLauncher.afterPropertiesSet();
		} catch (Exception e) {
			logger.error("创建simpleJobLauncher异常：{}",e.getMessage());
		return simpleJobLauncher;

package cn.yong.zheng.task;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.annotation.Resource;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.support.SimpleJobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
 * @author zhengyong
public class BlackListMemcacgeScheduledTask implements org.quartz.Job {
    private static final Logger logger = LoggerFactory.getLogger(BlackListMemcacgeScheduledTask.class);
    @Autowired
    private SimpleJobLauncher simpleJobLauncher;
    @Resource(name = "springBatchJob")
    private Job springBatchJob;
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        this.executeTask();
     * 定时任务执行计划
    private void executeTask() {
        try {
                JobExecution execution = simpleJobLauncher.run(springBatchJob,
                        new JobParametersBuilder().addLong("time", System.currentTimeMillis()).toJobParameters());
            } catch (Exception e) {
                logger.error("异常：{}", e.getMessage());
                    问题描述：使用spring batch 连接oracle操作时，总是报出如下异常：PreparedStatementCallback; SQL [INSERT into BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, JOB_KEY, VERSION) values (?, ?, ?, ?)]; ORA-08177: 无法连续访问此事务处理原
它组合了逻辑上属于流程的多个步骤，并允许配置所有步骤全局的属性
步它是一个域对象，封装了批处理作业的一个独立的顺序阶段
JobRepository 它是所有Jobs和Steps的持久性机制
JobLauncher 它代表启动Job的简单界面
物品阅读器它是一个抽象，代表对Step的输入的检索
项目作家它是代表Step输出的抽象
项目处理器它是代表项目业务处理的抽象
批处理配置
@Value("#{jobParameters['xxx']}")
 您可以通过命令行参数使用@Value("#{jobParameters['xxx']}")引用JobParameter。 该表达式被Spring Expre
1：服务没有开启（oracle的服务，oraclehome92TNSlistener）
2：数据库实例没有开启(oracleserviceORCL)
3：注册表中默认oracle_sid设置错误(oracle_id=ORCL)
http://apps.hi.b...
--会话A
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
select employee_id,first_name,last_name,email from employees where first_name='zou';
--会话B
update ...
问题分析：
1、Quartz从MySQL数据库换成Oracle数据库，并且org.quartz.jobStore.txIsolationLevelSerializable设置为true，出现了报错。
解决办法：
（1）注释掉Quartz配置类的@Configuration注解，代表不使用当前配置类，org.quartz.jobStore.txIs
由于最近需要改写一个批处理框架，看到spring batch非常符合需求，打算使用spring batch与spring boot实践下。在这里做个实践中遇到的问题汇总：
1.spring batch集成后，启动时报ORA-08177: 无法连续访问此事务处理？
项目搭建后，启动时报错ORA-08177: 无法连续访问此事务处理。查询后得到处理方法如下：
http://blog.c...
地址迁移器
address-migrator-boot-client-具有jdbc存储库的经典客户端示例
address-migrator-remote-repository-具有远程存储库的经典客户端示例
address-migrator-service-discovery-consul-领事发现客户端示例
地址迁移器服务发现-尤里卡-尤里卡发现客户端示例
lightmin-jpa应用
示例客户端，以演示如何为lightmin，JPA和Spring Batch设置数据源和事务管理器。
存储库服务器样本
spring-batch-lightmin-repository-server-sample
 样本存储库服务器应用程序
服务器样本
spring-batch
				
Spring行动
自2011年以来，未对Spring Batch In Action进行过修订，没有韩语翻译，韩国大部分的Spring Batch文章都是教程或官方文档的翻译。 随着商务或其他服务系统的发展，批处理工作会增加，但是在许多情况下，Spring Batch会以愚蠢的方式使用。 Spring MVC有很多数据，但是没有太多的批处理，所以我开始组织它。
简单批处理作业
审查工作执行结果
Job，JobInstance，JobExecution等。BATCH_JOB模式查看BatchExecution表的内容
BatchStatus简介
批处理作业流程
拆分和多线程
决定通过JobExecutionDecider进行步骤分支处理
批处理步骤简介
面向代码的块
读者处理器作家简介
@JobScope ， @StepScope ， @Value
				
ORA-01795是Oracle数据库中的一个异常，当在拼接SQL语句中使用了超过1000个参数的where in子句时，会抛出该异常。为了解决这个问题，可以将原SQL语句转换为等价的合法SQL语句。具体做法是将参数按照每1000个一组进行分组，然后使用多个where in子句进行连接。下面是一个示例的实现代码：
```java
private String GetWhereInValuesSql(String column, List<String> values) {
    String sql = "(";
    int valueSize = values.size();
    int batchSize = valueSize / 1000 + (valueSize % 1000 == 0 ? 0 : 1);
    for (int i = 0; i < batchSize; i++) {
        if (i > 0) {
            sql += ") or ";
        sql += column + " in (";
        for (int j = i * 1000; (j < (i + 1) * 1000) && j < valueSize; j++) {
            if (j > i * 1000) {
                sql += ",";
            sql += "'" + values.get(j) + "'";
    sql += "))";
    return sql;
这个方法可以将where in语句中的参数按照每1000个一组进行分组，并使用多个where in子句进行连接，从而避免了ORA-01795异常的出现。
#### 引用[.reference_title]
-  *1* *2* *3* [ORA-01795异常(where in超过1000)的解决](https://blog.csdn.net/free1985/article/details/75331393)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]