spring boot（多数据源）+spring batch 解决异常: java.lang.IllegalStateException

最新推荐文章于 2024-03-22 10:11:15 发布
最新推荐文章于 2024-03-22 10:11:15 发布
阅读量2.1w 收藏 3
点赞数 5
分类专栏： Java 文章标签： spring batch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uTechCore/article/details/52796876
版权

项目集成说明：

 spring boot（配置多数据源）
 spring batch

数据源配置文件：

@Configuration
public class DataSourceConfig {

    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

spring batch配置文件：

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {

    //读数据
    @Autowired private ReaderService readerService;
    //处理数据
    @Autowired private PersonItemProcessor processor;
    //写数据
    @Autowired private WriterService writerService;

    @Autowired private JobBuilderFactory jobBuilderFactory;
    @Autowired private StepBuilderFactory stepBuilderFactory;

    /**
     * 异常监听
     * @return
     */
    @Bean
    public JobExecutionListener listener() {
        return new JobNotification();
    }

    /**
     * 导入任务
     */
    @Bean
    public Job importUserJob() {
        return jobBuilderFactory.get("importUserJob")
                .incrementer(new RunIdIncrementer())
                .listener(listener())
                .flow(step1())
                .end()
                .build();
    }

    /**
     * 执行步骤
     */
    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<Person, Person> chunk(10)
                .reader( readerService.readerDatabase() )
                .processor( processor )
                .writer( writerService.writerDatabase() )
                .build();
    }
}

启动spring boot 报错：


***************************
APPLICATION FAILED TO START
***************************

Description:

Field dataSource in com.scp.hello.reader.ReaderService required a single bean, but 2 were found:
    - primaryDataSource: defined by method 'primaryDataSource' in class path resource [com/scp/hello/DataSourceConfig.class]
    - secondaryDataSource: defined by method 'secondaryDataSource' in class path resource [com/scp/hello/DataSourceConfig.class]


Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed


Process finished with exit code 1

异常说明：多个数据源中没有指定一个默认数据源。
解决方法：在一个数据源，添加注解@Primary即可。

再次启动spring boot项目，出现异常信息如下：

java.lang.IllegalStateException: Failed to execute CommandLineRunner
    at org.springframework.boot.SpringApplication.callRunner(SpringApplication.java:803) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.callRunners(SpringApplication.java:784) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.afterRefresh(SpringApplication.java:771) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:316) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1186) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1175) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at com.scp.SpringBatchApplication.main(SpringBatchApplication.java:12) [classes/:na]
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_73]
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_73]
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_73]
    at java.lang.reflect.Method.invoke(Method.java:497) ~[na:1.8.0_73]
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147) [idea_rt.jar:na]
Caused by: java.lang.IllegalStateException: To use the default BatchConfigurer the context must contain no more thanone DataSource, found 2
    at org.springframework.batch.core.configuration.annotation.AbstractBatchConfiguration.getConfigurer(AbstractBatchConfiguration.java:108) ~[spring-batch-core-3.0.7.RELEASE.jar:3.0.7.RELEASE]
    at org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration.initialize(SimpleBatchConfiguration.java:114) ~[spring-batch-core-3.0.7.RELEASE.jar:3.0.7.RELEASE]
    at org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration$ReferenceTargetSource.createObject(SimpleBatchConfiguration.java:142) ~[spring-batch-core-3.0.7.RELEASE.jar:3.0.7.RELEASE]
    at org.springframework.aop.target.AbstractLazyCreationTargetSource.getTarget(AbstractLazyCreationTargetSource.java:86) ~[spring-aop-4.3.3.RELEASE.jar:4.3.3.RELEASE]
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:192) ~[spring-aop-4.3.3.RELEASE.jar:4.3.3.RELEASE]
    at com.sun.proxy.$Proxy45.getJobInstances(Unknown Source) ~[na:na]
    at org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner.getNextJobParameters(JobLauncherCommandLineRunner.java:133) ~[spring-boot-autoconfigure-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner.execute(JobLauncherCommandLineRunner.java:214) ~[spring-boot-autoconfigure-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner.executeLocalJobs(JobLauncherCommandLineRunner.java:233) ~[spring-boot-autoconfigure-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner.launchJobFromProperties(JobLauncherCommandLineRunner.java:125) ~[spring-boot-autoconfigure-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.autoconfigure.batch.JobLauncherCommandLineRunner.run(JobLauncherCommandLineRunner.java:119) ~[spring-boot-autoconfigure-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    at org.springframework.boot.SpringApplication.callRunner(SpringApplication.java:800) [spring-boot-1.4.1.RELEASE.jar:1.4.1.RELEASE]
    ... 11 common frames omitted

异常指出：To use the default BatchConfigurer the context must contain no more thanone DataSource, found 2

异常原因：spring batch启动时，AbstractBatchConfiguration尝试首先在Spring容器中查找BatchConfigurer，如果没有找到，则尝试创建它本身， 这时在容器中找到多个DataSource 的实例，因此抛出IllegalStateException异常。

解决方法：

@Configuration
@EnableBatchProcessing
@ComponentScan(basePackageClasses = DefaultBatchConfigurer.class)
public class BatchConfiguration {

添加注解：@ComponentScan 扫描 DefaultBatchConfigurer.class datasource注入成功。

参考博客（Stack Overflow）：
http://stackoverflow.com/questions/25540502/use-of-multiple-datasources-in-spring-batch

uTechCore
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
致命问题多数据源引发SpringBatch多事物
境里婆娑
11-28 1259
文章目录一、如何查看SpringBatch原数据和业务数据是一个事物二、多数据源如何引发SpringBatch多事物 写在前面： 我是「境里婆娑」。我还是从前那个少年，没有一丝丝改变，时间只不过是考验，种在心中信念丝毫未减，眼前这个少年，还是最初那张脸，面前再多艰险不退却。 写博客的目的就是分享给大家一起学习交流，如果您对 Java感兴趣，可以关注我，我们一起学习。 前言：我们项目在运行的时候出现了多事物问题，SpringBatch原数据表提交和业务表数据提交用的不是一个事物，这在项目运行中是一个非常致
spring boot多数据源(AOP注解动态切换）
07-20
spring boot整合druid连接池，采用注解方式实现多数据源动态切换 jdk版本1.8 spring boot版本1.5.14
springboot和mybtais 多数据源使用BATCH方法进行批量新增
zhongzih的博客
01-14 1461
@Configuration @MapperScan(basePackages = "com.jumper.medical.nt.mapper", sqlSessionFactoryRef = "ntSessionFactory",sqlSessionTemplateRef="sqlSessionTemplateNt") public class NtDataSourceConfigurer { @Bean public SqlSessionFactory ntSessionFactory
A batch-processing system base on Spring Boot and Spring B.zip
02-22
opengl
nacos启动报错 java.lang.IllegalStateException: No DataSource set
最新发布
qq_51637768的博客
03-22 560
配置了数据源之后，启动报错Caused by: java.lang.IllegalStateException: No DataSource set。mysql我使用的是8.0以上版本所以要加上这个:allowPublicKeyRetrieval=true。进入conf文件夹，找到mysql-schema.sql文件，在数据库生成表后，启动成功。我这里的问题是，启动nacos，nacos不会在数据库自动生成相关配置表。意思是数据源没有设置，以为是数据库url配置错误，检查了很多遍都没有问题。
magic-batch:演示项目-Java 8-Spring Boot-Redis
05-03
魔术批 使用Java 8+构建，Spring Boot（2.0.3）Redis（3.0.4） 经过JUnit（4.12）和JMeter的测试 通过带有三个Spring配置文件（dev，qa，dk）的Spring Boot执行-假定mvn clean install dev Profile异步处理批处理并注销数据 mvn spring-boot:run -Drun.arguments="-Xmx256m,-Xms128m" qa配置文件需要Redis运行（通过application-qa.properties配置） mvn spring-boot:run -Drun.profiles=qa -Drun.arguments="-Xmx256m,-Xms128m" dk配置文件需要Docker（通过application-dk.properties配置） docker-compose
Spring实现动态切换多数据源的解决方案
08-31
主要给大家介绍了Spring实现动态切换多数据源的解决方案,文中给出了详细的介绍和示例代码，相信对大家的理解和学习具有一定的参考借鉴价值，有需要的朋友可以参考学习，下面来一起看看吧。
springBoot+springBatch批量处理数据demo
02-29
最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
报错：java.lang.IllegalStateException: Failed to execute CommandLineRunner
Baichi_00的博客
04-26 3万+
一.踩坑描述： 废话不多说，先奉上报错日志： 事情经过就是某天早上上班本地启动项目时，发现报错了（如上），项目无法正常启动。（日常掉坑踩雷～～） 二.分析原因： 1、项目引用的ES版本和ES服务的版本不一样； 2、端口配置不正确 3、服务器es中的yml配置文件cluster.name与本地配置文件不一致 4、ES服务没启动（可能性最大）； 三.解决方案：（针对最后一种情况） 1.查看进程是否存在： 2.重启elasticsearch： 1.切换到es用户下： su es 2.在ES服务bin目录执行：
springboot配置多数据源
未知的希望，是我不灭的信仰
03-03 1261
springboot配置多数据源
【DEBUG】SpringBoot2+Mybatis启动时报错：java.lang.IllegalStateException: Failed to execute CommandLineRunner
JZJ_LYH的博客
10-20 927
SpringBoot2+Mybatis启动时报错：java.lang.IllegalStateException: Failed to execute CommandLineRunner
Springbatch Failed to execute CommandLineRunner报错解决
热门推荐
ZhangYuan2HH的博客
04-25 6万+
Springbatch Failed to execute CommandLineRunner报错解决 java.lang.IllegalStateException: Failed to execute CommandLineRunner at org.springframework.boot.SpringApplication.callRunner(SpringApplication....
决战数据库-spring batch(4)数据库到数据库
masson32的专栏
06-09 7864
决战数据库-spring batch(4)数据库到数据库 tags：springbatch 文章目录决战数据库-spring batch(4)数据库到数据库1.引言2.开发环境3.开发流程3.1 创建目标数据库3.2 配置多数据源3.3 添加读数据组件`JdbcCursorItemReader`3.4 自定义处理组件`Db2DbItemProcessor`3.5 添加写数据组件`JdbcBatc...
Spring Batch 批处理框架优化实践，效率嘎嘎高！
Java知音
10-16 264
一、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 修改...
springboot 整合多数据源手动切换
weixin_42324034的博客
09-09 707
配置文件如下 server.port = 11000 #热部署 spring.devtools.restart.enabled=true spring.aop.auto=true # DB Configuration #指定数据1库驱动 spring.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver #数据库1jdbc连接url地址,serverTimezone设置数据库时区东八区 spring.datasource.db1.jdbc-u
java.lang.IllegalStateException异常产生的原因及解决办法
Vivian的博客
02-22 1万+
servlet的生命周期问题等： 解决方法：保存后重新启动服务器；    
Spring Batch使用不支持的数据库
qq_34622881的博客
06-29 887
开发任务将oracle转为达梦,然而spring Batch并不支持。会报DatabaseType找不到 我们也可以从源码中看出DatabaseType这个枚举并没有达梦 https://docs.spring.io/spring-batch/docs/current/reference/html/index-single.html#repeat 官方手册大概应该是使用接近数据源的数据库（博主英文不好） @Configuration @EnableBatchProcessing public clas
idea中springboot实现canal同步报错：java.lang.IllegalStateException: Failed to execute CommandLineRunner
RosLu的博客
08-29 1万+
报错信息为： 解决方法： 可能是Linux防火墙没有关闭。关闭防火墙即可！ ###################################### CentOS 8 防火墙关闭等命令 1--查看防火墙状态 systemctl status firewalld.service 2--开启防火墙 systemctl start firewalld.service 3--关闭防火墙 systemctl stop firewalld.service 4--禁用防火墙 syst.
Spring Batch批处理框架优化实践，提高数据处理效率和质量
BXA
05-17 1804
Spring Batch是一种用于批处理的框架基于Spring Framework开发，通过读取大量的数据、处理数据和写入大量数据来满足各种类型的企业级批处理需求。Spring Batch可以很好地处理大量数据，并且提供了丰富的可扩展组件，业务逻辑与框架层的一系列处理步骤的集成也比较简单。Spring Batch可以很好地支持程序员针对大量的数据，编写代码来执行规范的操作序列，提高开发效率，降低了对于数据库等系统资源访问的影响。
Spring-boot+Spring-batch+hibernate+Quartz简单批量读文件写数据用例
08-09
### 回答1： 下面是一个简单的Spring Boot + Spring Batch + Hibernate + Quartz的批量读文件写数据的例子： 1. 创建Spring Boot项目 首先，我们需要创建一个Spring Boot项目。可以使用Spring Initializr或者手动创建一个Maven项目。在pom.xml文件中添加相关依赖： ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-batch</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> </dependencies> ``` 2. 创建Job 接下来，我们要创建一个Job。Job是一个执行具体任务的实体，可以包含一个或多个Step。 ```java @Configuration public class JobConfiguration { @Autowired private JobBuilderFactory jobBuilderFactory; @Autowired private StepBuilderFactory stepBuilderFactory; @Autowired private DataSource dataSource; @Bean public FlatFileItemReader<Person> reader() { FlatFileItemReader<Person> reader = new FlatFileItemReader<>(); reader.setResource(new ClassPathResource("persons.csv")); reader.setLineMapper(new DefaultLineMapper<Person>() {{ setLineTokenizer(new DelimitedLineTokenizer() {{ setNames(new String[]{"firstName", "lastName", "email"}); }}); setFieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {{ setTargetType(Person.class); }}); }}); return reader; } @Bean public PersonItemProcessor processor() { return new PersonItemProcessor(); } @Bean public JpaItemWriter<Person> writer() { JpaItemWriter<Person> writer = new JpaItemWriter<>(); writer.setEntityManagerFactory(entityManagerFactory().getObject()); return writer; } @Bean public Job importUserJob(JobCompletionNotificationListener listener) { return jobBuilderFactory.get("importUserJob") .incrementer(new RunIdIncrementer()) .listener(listener) .flow(step1()) .end() .build(); } @Bean public Step step1() { return stepBuilderFactory.get("step1") .<Person, Person>chunk(10) .reader(reader()) .processor(processor()) .writer(writer()) .build(); } @Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource); em.setPackagesToScan("com.example.demo"); em.setJpaVendorAdapter(new HibernateJpaVendorAdapter()); em.setJpaProperties(additionalProperties()); return em; } private Properties additionalProperties() { Properties properties = new Properties(); properties.setProperty("hibernate.hbm2ddl.auto", "create-drop"); properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); return properties; } } ``` Job主要包含以下几个部分： - reader：读取文件中的数据 - processor：处理每一条数据 - writer：将数据写入数据库 - step：定义一个Step - job：定义一个Job，包含一个或多个Step 3. 创建任务调度 接下来，我们需要创建一个任务调度，使用Quartz来实现。我们可以在应用启动时，自动启动任务调度。以下是一个简单的任务调度配置： ```java @Configuration public class SchedulerConfiguration { @Autowired private JobLauncher jobLauncher; @Autowired private Job importUserJob; @Bean public JobDetail jobDetail() { return JobBuilder.newJob().ofType(SpringJobAdapter.class) .storeDurably() .withIdentity("importUserJob") .withDescription("Invoke Spring batch from quartz") .build(); } @Bean public Trigger trigger(JobDetail job) { SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule() .withIntervalInSeconds(60) .repeatForever(); return TriggerBuilder.newTrigger().forJob(job) .withIdentity("importUserTrigger") .withDescription("Simple trigger") .withSchedule(scheduleBuilder) .build(); } @Bean public Scheduler scheduler(Trigger trigger, JobDetail job) throws SchedulerException { SchedulerFactory factory = new StdSchedulerFactory(); Scheduler scheduler = factory.getScheduler(); scheduler.scheduleJob(job, trigger); scheduler.setJobFactory(springBeanJobFactory()); scheduler.start(); return scheduler; } @Bean public SpringBeanJobFactory springBeanJobFactory() { return new AutowiringSpringBeanJobFactory(); } public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware { private transient AutowireCapableBeanFactory beanFactory; @Override public void setApplicationContext(ApplicationContext context) { beanFactory = context.getAutowireCapableBeanFactory(); } @Override protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception { final Object job = super.createJobInstance(bundle); beanFactory.autowireBean(job); return job; } } } ``` 这里我们使用了Spring JobAdapter来将Spring Batch的Job包装成Quartz Job。同时，我们也定义了一个Simple Trigger，每隔60秒执行一次。 4. 编写数据处理逻辑 最后，我们需要编写具体的数据处理逻辑。这里我们简单的将读取到的Person数据插入到数据库中。以下是一个简单的数据处理类： ```java public class PersonItemProcessor implements ItemProcessor<Person, Person> { @Override public Person process(Person person) throws Exception { return person; } } ``` 5. 创建数据模型 在这个例子中，我们需要处理的数据是Person，我们需要创建一个Person类来描述数据模型： ```java @Entity public class Person { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String firstName; private String lastName; private String email; // getter and setter } ``` 6. 创建文件 最后，我们需要创建一个csv文件，用于存储测试数据。文件名为persons.csv，内容如下： ```csv firstName,lastName,email John,Doe,[email protected] Jane,Doe,[email protected] Bob,Smith,[email protected] Alice,Smith,[email protected] ``` 7. 运行程序 完成以上步骤后，我们可以运行程序。当程序运行时，任务调度会定时执行任务，将csv文件中的数据插入到数据库中。 总的来说，这是一个简单的Spring Boot + Spring Batch + Hibernate + Quartz的批量读文件写数据的例子。通过这个例子，可以熟悉Spring Batch的基本使用方法，并了解如何使用Quartz实现任务调度。 ### 回答2： Spring Boot是一种快速开发应用程序的框架，Spring Batch是Spring Boot的子项目，用于处理大量数据的批量处理任务。在这个用例中，我们可以使用Spring Boot、Spring Batch、Hibernate和Quartz来实现简单的批量读取文件并写入数据。 首先，我们需要在Spring Boot项目中引入Spring Batch和Hibernate的依赖。然后，创建一个包含读取文件和写入数据的批处理任务。 使用Spring Batch的ItemReader接口从文件中逐行读取数据。你可以使用FlatFileItemReader类并配置文件路径、行解析器等属性来实现这一步骤。 接下来，使用Hibernate的Entity类和Repository来定义和操作数据表。根据业务需求，创建一个实体类并使用JPA注解配置。然后，创建一个Repository接口，用于查询和保存数据。 在批处理任务的写入步骤中，我们可以使用Hibernate的Session来保存数据。通过调用Repository的save方法，将读取到的数据写入数据库。 最后，使用Quartz来触发批处理任务。可以配置Quartz的定时任务，按照一定的时间间隔或特定时间点触发批处理任务的执行。 在整个过程中，我们需要根据实际需求进行配置和开发，确保数据的正确读取和写入。可以使用Spring Boot自带的自动配置或者手动配置来实现以上功能。 综上所述，我们可以使用Spring Boot、Spring Batch、Hibernate和Quartz来实现简单的批量读取文件并写入数据的用例。这个用例可以用来处理大量数据的批处理任务，实现数据的批量处理和定时执行。 ### 回答3： Spring Boot是一个用于创建独立的、基于Spring的生产级应用程序的框架。它简化了Spring应用程序的配置和部署过程，并提供了一套强大的开发工具和约定，使开发人员能够更快地构建应用程序。 Spring Batch是一个用于批量处理的框架。它提供了一种简单而强大的方式来处理大量的数据，并允许我们以可靠的方式处理失败和重试。它还提供了许多批处理作业开发和管理的功能，如读取数据源、处理数据并将结果写入目标数据源。 Hibernate是一个用于对象关系映射(ORM)的框架。它简化了Java应用程序与关系数据库之间的交互，并提供了一个对象导向的方式来操作数据。它提供了一种将对象持久化到数据库中的简单方式，并为开发人员提供了一套强大的查询语言(HQL)来执行复杂的数据库查询操作。 Quartz是一个用于任务调度的框架。它允许我们按照预定的时间间隔或时间短划进行任务调度。它还提供了一种强大的任务管理和监控机制，可以处理并发任务，并支持持久化任务调度信息。 下面是一个简单的批量读取文件并将数据写入数据库的示例： 1. 使用Spring Boot创建一个新的Web应用程序。 2. 导入Spring Batch、Hibernate和Quartz的依赖项。 3. 创建一个包含文件读取、数据处理和数据写入的Spring Batch作业。 4. 在作业中使用Hibernate作为数据源读取文件的内容。 5. 配置Quartz来调度作业的执行。 6. 在作业中实现一个写入数据库的处理器。 7. 配置Hibernate来将处理后的数据写入数据库。 8. 运行应用程序并观察任务按计划执行，并且文件中的数据被正确地写入数据库。 这个示例演示了如何使用Spring Boot、Spring Batch、Hibernate和Quartz来构建一个简单的批量处理应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值