问题描述：
我们的项目平时并发量并不算大，但是有一天客户联系我们，说会出现交易卡死，所有交易无法进行，大约等待一分钟后会恢复的现象。后来检查日志，发现日志中有大量的等待数据库连接超时的问题
原因分析：
先写一下大致的代码结构：
├─src
└──main
└──java
└──com.example.test
└──controll
m...
管理员功能:
管理员信息：售票管理员和检票管理员的信息，管理员主要是增删改查有关管理员的数据信息
车辆管理：管理员进入指定功能操作区之后可以管理车辆信息，包括了售票管理员和检票管理员的信息，管理员主要是增删改查有关管理员的数据信息。
车辆调度管理:查看已发布的物流信息数据，修改物流信息，物流信息作废，即可删除。包括修改车辆的排班信息，新增车辆调度信息，根据排班信息查询车辆调度信息。
系统公告管理:管理员进入指定功能操作区之后可以管理系统公告。只有管理员才可以管理系统公告，发布公告信息，其他角色用户只能查看。
售票管理:管理员进入指定功能操作区之后可以管理售票。管理员本人也能增删改查售票信息，还可以统计各种车辆的售票信息。
这里是一个简单的
Spring-boot
+
Spring
-batch+hibernate+Quartz 的批量读文件写数据的例子。
首先，需要在 pom.xml 文件中添加以下依赖：
```xml
<dependency>
<groupId>org.
spring
framework.
boot
</groupId>
<artifactId>
spring-boot
-starter-batch</artifactId>
</dependency>
<dependency>
<groupId>org.
spring
framework.
boot
</groupId>
<artifactId>
spring-boot
-starter-quartz</artifactId>
</dependency>
<dependency>
<groupId>org.
spring
framework.
boot
</groupId>
<artifactId>
spring-boot
-starter-
data
-
jpa
</artifactId>
</dependency>
在 application.yml 文件中配置数据源和 Quartz：
```yaml
spring
:
data
source:
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: root
jpa
:
hibernate:
ddl-auto: update
show-sql: true
quartz:
job-store-type: jdbc
jdbc:
initialize-schema: always
接下来，定义实体类 File
Data
：
```java
@Entity
@Table(name = "file_
data
")
public class File
Data
{
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "file_name")
private String fileName;
@Column(name = "line_number")
private Integer lineNumber;
@Column(name = "line_
data
")
private String line
Data
;
// getter and setter
定义读取文件的 ItemReader：
```java
@Component
@StepScope
public class FileItemReader implements ItemReader<String> {
private static final Logger LOGGER = LoggerFactory.getLogger(FileItemReader.class);
private String file;
private BufferedReader reader;
@Value("#{jobParameters['file']}")
public void setFile(String file) {
this.file = file;
@BeforeStep
public void beforeStep(StepExecution stepExecution) throws Exception {
LOGGER.info("Starting to read file: {}", file);
reader = new BufferedReader(new FileReader(file));
@Override
public String read() throws Exception {
String line = reader.readLine();
if (line != null) {
LOGGER.debug("Read line: {}", line);
} else {
LOGGER.info("Finished reading file: {}", file);
reader.close();
return line;
定义处理数据的 ItemProcessor：
```java
@Component
public class FileItemProcessor implements ItemProcessor<String, File
Data
> {
private static final Logger LOGGER = LoggerFactory.getLogger(FileItemProcessor.class);
@Override
public File
Data
process(String line) throws Exception {
LOGGER.debug("Processing line: {}", line);
String[] parts = line.split(",");
File
Data
file
Data
= new File
Data
();
file
Data
.setFileName(parts[0]);
file
Data
.setLineNumber(Integer.parseInt(parts[1]));
file
Data
.setLine
Data
(parts[2]);
return file
Data
;
定义写数据的 ItemWriter：
```java
@Component
public class FileItemWriter implements ItemWriter<File
Data
> {
private static final Logger LOGGER = LoggerFactory.getLogger(FileItemWriter.class);
@Autowired
private EntityManager entityManager;
@Override
@Transactional
public void write(List<? extends File
Data
> items) throws Exception {
LOGGER.info("Writing {} items", items.size());
for (File
Data
item : items) {
entityManager.persist(item);
entityManager.flush();
定义 Job：
```java
@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
@Autowired
private JobBuilderFactory jobBuilderFactory;
@Autowired
private StepBuilderFactory stepBuilderFactory;
@Autowired
private FileItemReader fileItemReader;
@Autowired
private FileItemProcessor fileItemProcessor;
@Autowired
private FileItemWriter fileItemWriter;
@Bean
public Job fileTo
Data
baseJob() {
return jobBuilderFactory.get("fileTo
Data
baseJob")
.incrementer(new RunIdIncrementer())
.start(step1())
.build();
@Bean
public Step step1() {
return stepBuilderFactory.get("step1")
.<String, File
Data
>chunk(10)
.reader(fileItemReader)
.processor(fileItemProcessor)
.writer(fileItemWriter)
.build();
定义 Quartz 定时任务：
```java
@Component
public class FileTo
Data
baseJobScheduler {
@Autowired
private SchedulerFactory schedulerFactory;
@Autowired
private JobDetail fileTo
Data
baseJobDetail;
@Autowired
private CronTriggerFactoryBean fileTo
Data
baseJobTrigger;
@PostConstruct
public void scheduleFileTo
Data
baseJob() throws SchedulerException {
Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.scheduleJob(fileTo
Data
baseJobDetail, fileTo
Data
baseJobTrigger.getObject());
scheduler.start();
最后，
启动
应用程序并将文件作为参数传递：
```java
@
Spring
Boot
Application
public class Application {
public static void main(String[] args) {
Spring
Application.run(Application.class, args);
@Bean
@StepScope
public FileItemReader fileItemReader(@Value("#{jobParameters['file']}") String file) {
FileItemReader reader = new FileItemReader();
reader.setFile(file);
return reader;
@Bean
public JobDetail fileTo
Data
baseJobDetail() {
return JobBuilder.newJob(BatchConfiguration.class)
.withIdentity("fileTo
Data
baseJob")
.storeDurably()
.build();
@Bean
public CronTriggerFactoryBean fileTo
Data
baseJobTrigger(@Autowired JobDetail fileTo
Data
baseJobDetail) {
CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
trigger.setJobDetail(fileTo
Data
baseJobDetail);
trigger.setCronExpression("0 0/1 * 1/1 * ? *"); // 每分钟执行一次
return trigger;
以上就是一个简单的
Spring-boot
+
Spring
-batch+hibernate+Quartz 的批量读文件写数据的例子。
