spring batch的使用和定时器Quart的使用

Spring Batch是一个基于Spring的企业级批处理框架，它通过配合定时器Quartz来轻易实现大批量的数据读取或插入，并且全程自动化，无需人员管理。

在使用spring batch之前，得对spring batch的流程有一个基本了解

每个batch它都包含了一个job，而一个job中却有可能包含多个step，整个batch中干活的是step，batch主要是用来对数据的操作，所以step就有三个操作数据的东西，一个是ItemReader用来读取数据的，一个是ItemProcessor用来处理数据的，一个是ItemWriter用来写数据（可以是文件也可以是插入sql语句），JobLauncher用来启动Job，JobRepository是上述处理提供的一种持久化机制，它为JobLauncher，Job，和Step实例提供CRUD操作。

pom.xml  三个batch的jar包

1. <span style="white-space:pre;">     </span><dependency>
2. <groupId>org.springframework</groupId>
3. <artifactId>spring-batch-core</artifactId>
4. <version>2.1.8.RELEASE</version>
5. </dependency>
6. <dependency>
7. <groupId>org.springframework</groupId>
8. <artifactId>spring-batch-infrastructure</artifactId>
9. <version>2.1.8.RELEASE</version>
10. <span style="white-space:pre;"> </span></dependency>
11. <dependency>
12. <groupId>org.springframework</groupId>
13. <artifactId>spring-batch-test</artifactId>
14. <version>2.1.8.RELEASE</version>
15. </dependency>

batch.xml

1. <beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:batch="http://www.springframework.org/schema/batch" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://www.springframework.org/schema/batch
4. http://www.springframework.org/schema/batch/spring-batch-2.1.xsd
5. http://www.springframework.org/schema/beans
6. http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
7. ">
8. <bean id="jobLauncher"
9. class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
10. <property name="jobRepository" ref="jobRepository" />
11. </bean>
12. <bean id="jobRepository"
13. class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
14. <property name="validateTransactionState" value="false" />
15. </bean>
16. <span style="white-space:pre;">     </span><!--一个job-->
17. <batch:job id="writerteacherInterview">
18. <batch:step id="teacherInterview">
19. <batch:tasklet>
20. <batch:chunk reader="jdbcItemReaderTeacherInterview" writer="teacherInterviewItemWriter"
21. processor="teacherInterviewProcessor" commit-interval="10">
22. </batch:chunk>
23. </batch:tasklet>
24. </batch:step>
25. </batch:job>
26. <!--job的读取数据操作-->
27. <bean id="jdbcItemReaderTeacherInterview"
28. class="org.springframework.batch.item.database.JdbcCursorItemReader"
29. scope="step">
30. <property name="dataSource" ref="dataSource" />
31. <property name="sql"
32. value="select distinct teacherName ,count(teacherName) as num from examininterviewrecord   where pdate >'${detail_startime}' and pdate < '${detail_endtime}'  GROUP BY teacherName " />
33. <property name="rowMapper" ref="teacherInterviewMapper">
34. </property>
35. </bean>
36. </beans>

读取数据    teacherInterviewMapper

1. package com.yc.batch;
2. import java.sql.ResultSet;
3. import java.sql.SQLException;
4. import org.springframework.jdbc.core.RowMapper;
5. import org.springframework.stereotype.Component;
6. import com.yc.vo.TeacherInterviewdetail;
7. import com.yc.vo.TeacherWorkdetail;
8. import com.yc.vo.Workdetail;
9. @Component("teacherInterviewMapper")
10. public class TeacherInterviewMapper implements RowMapper {
11. @Override
12. public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
13. TeacherInterviewdetail TId=new TeacherInterviewdetail();
14. TId.setTeacherName(rs.getString("teacherName"));
15. TId.setNum(rs.getInt("num"));
16. return TId;
17. }
18. }

处理数据  teacherInterviewProcessor ，这个处理数据方法，一般都是在这里在这里进行一些数据的加工，比如有些数据没有读到，你也可以在这个方法和后面那个写入数据的类里面写，所以就导致了这个类里面你可以什么都不敢，直接把数据抛到后面去，让后面的写数据类来处理；我这里就是处理数据的这个类什么都没写，但是最好还是按它的规则来！

1. package com.yc.batch;
2. import org.hibernate.engine.transaction.jta.platform.internal.SynchronizationRegistryBasedSynchronizationStrategy;
3. import org.springframework.batch.item.ItemProcessor;
4. import org.springframework.stereotype.Component;
5. import org.springframework.stereotype.Service;
6. import com.yc.vo.TeacherInterviewdetail;
7. import com.yc.vo.TeacherWorkdetail;
8. import com.yc.vo.Workdetail;
9. //业务层
10. @Component("teacherInterviewProcessor")
11. public class TeacherInterviewProcessor implements ItemProcessor<TeacherInterviewdetail, TeacherInterviewdetail> {
12. @Override
13. public TeacherInterviewdetail process(TeacherInterviewdetail teacherInterviewdetail) throws Exception {
14. return teacherInterviewdetail;
15. }
16. }

写数据 teacherInterviewItemWriter 这个类里面主要是把数据写进一个文件里，同时我这个类里面还有一些数据处理

1. package com.yc.batch;
2. import java.io.InputStream;
3. import java.text.NumberFormat;
4. import java.util.ArrayList;
5. import java.util.List;
6. import java.util.Properties;
7. import javax.annotation.Resource;
8. import org.springframework.batch.item.ItemWriter;
9. import org.springframework.stereotype.Component;
10. import org.springframework.stereotype.Service;
11. import com.yc.biz.ExamineeClassBiz;
12. import com.yc.biz.WorkBiz;
13. import com.yc.utils.CsvUtils;
14. import com.yc.vo.TeacherInterviewdetail;
15. import com.yc.vo.TeacherWorkdetail;
16. import com.yc.vo.Workdetail;
17. import net.sf.ehcache.util.PropertyUtil;
18. //写
19. @Component("teacherInterviewItemWriter")
20. public class TeacherInterviewItemWriter implements ItemWriter<TeacherInterviewdetail>{
21. @Override
22. public void write(List<? extends TeacherInterviewdetail> teacherInterviewdetails) throws Exception {
23. Properties props = new Properties();
24. InputStream in= PropertyUtil.class.getClassLoader().getResourceAsStream("connectionConfig.properties");
25. props.load(in);
26. String time=props.getProperty("detail_time");
27. CsvUtils cu=new CsvUtils();
28. List<Object> works=new ArrayList<Object>();
29. for(TeacherInterviewdetail t:teacherInterviewdetails){
30. works.add(t);
31. }
32. String path=this.getClass().getResource("/").getPath();
33. path=path.substring(0,path.lastIndexOf("/"));
34. path=path.substring(0,path.lastIndexOf("/"));
35. path=path.substring(0,path.lastIndexOf("/"));
36. path=path.substring(0,path.lastIndexOf("/"));
37. cu.writeCsv(path+"/csv/teacherInterview_"+time+".csv",works );
38. }
39. }

我这里有用到一个吧数据写进CSV文件的jar包

1. <span style="white-space:pre;">         </span><dependency>
2. <groupId>net.sourceforge.javacsv</groupId>
3. <artifactId>javacsv</artifactId>
4. <version>2.0</version>
5. </dependency>

CsvUtils帮助类的写入CSV文件方法

1. /**
2. * 写入CSV文件
3. * @throws IOException
4. */
5. public void writeCsv(String path,List<Object> t) throws IOException{
6. String csvFilePath = path;
7. String filepath=path.substring(0,path.lastIndexOf("/"));
8. File f=new File(filepath);
9. if(!f.exists()){
10. f.mkdirs();
11. }
12. File file=new File(path);
13. if(!file.exists()){
14. file.createNewFile();
15. }
16. CsvWriter wr =new CsvWriter(csvFilePath,',',Charset.forName("GBK"));
17. try {
18. for(Object obj:t){
19. String[] contents=obj.toString().split(",");
20. wr.writeRecord(contents);
21. }
22. wr.close();
23. } catch (IOException e) {
24. e.printStackTrace();
25. }
26. }

就这样一个基本的batch流程就跑起来了，它通过从数据里读取一些数据，然后经过处理后，被存进服务器下的一个文件里面，之后像这种数据的读取就不需要去数据库里面

查询了，而是可以直接通过读取CSV文件来处理这个业务。一般使用这个的都会配一个定时器，让它们每隔一段时间跑一次，从而获得较新的数据

下面是定时器的配置

定时器的配置非常简单，我是使用注解方式来配置的

定时器任务类

1. package com.yc.task.impl;
2. import javax.transaction.Transactional;
3. import org.springframework.batch.core.JobParametersInvalidException;
4. import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
5. import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
6. import org.springframework.batch.core.repository.JobRestartException;
7. import org.springframework.batch.item.ItemProcessor;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.scheduling.annotation.Scheduled;
10. import org.springframework.stereotype.Component;
11. import org.springframework.stereotype.Service;
12. import com.yc.batch.ClassBatch;
13. import com.yc.batch.MessageItemBatch;
14. import com.yc.batch.TeacherInterviewBatch;
15. import com.yc.batch.TearcherBatch;
16. import com.yc.po.Work;
17. import com.yc.task.WorkTask;
18. import com.yc.vo.Workdetail;
19. @Service
20. public class WorkTaskImpl implements WorkTask{
21. @Autowired
22. private TeacherInterviewBatch teacherInterviewBatch;//教师访谈记录
23. public void setTeacherInterviewBatch(TeacherInterviewBatch teacherInterviewBatch) {
24. this.teacherInterviewBatch = teacherInterviewBatch;
25. }
26. @Scheduled(cron= "0 30 22 * * ?")   //每天晚上十点30执行一次  这个注解会让框架会自动把这个方法看成任务启动方法
27. @Override
28. public void task() {
29. try {
30. teacherInterviewBatch.test();//教师访谈
31. } catch (Exception e) {
32. e.printStackTrace();
33. }
34. }
35. }

定时器所真正要执行的方法

1. package com.yc.batch;
2. import javax.annotation.Resource;
3. import org.apache.commons.jexl2.Main;
4. import org.springframework.batch.core.Job;
5. import org.springframework.batch.core.JobExecution;
6. import org.springframework.batch.core.JobParameters;
7. import org.springframework.batch.core.JobParametersBuilder;
8. import org.springframework.batch.core.JobParametersInvalidException;
9. import org.springframework.batch.core.launch.JobLauncher;
10. import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
11. import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
12. import org.springframework.batch.core.repository.JobRestartException;
13. import org.springframework.beans.factory.annotation.Autowired;
14. import org.springframework.stereotype.Component;
15. @Component
16. public class TeacherInterviewBatch {
17. private Job job;
18. private JobLauncher launcher;
19. @Resource(name="writerteacherInterview")
20. public void setJob(Job job) {
21. this.job = job;
22. }
23. @Autowired
24. public void setLauncher(JobLauncher launcher) {
25. this.launcher = launcher;
26. }
27. public void test() throws JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException{
28. JobParameters jobParameters =
29. new JobParametersBuilder()
30. .addLong("time",System.currentTimeMillis()).toJobParameters();
31. JobExecution result = launcher.run(job, jobParameters);
32. }
33. }

就这样batch就被定时器调度起来了，每天十点准时使用batch来操作数据

转自：https://blog.csdn.net/pttaoge/article/details/76684656