elasticjob+spring 和 springboot（2）实测通过

最新推荐文章于 2024-08-15 16:54:51 发布

秦时于归化明月

最新推荐文章于 2024-08-15 16:54:51 发布

阅读量379

点赞数

文章标签： springboot elasticjob

本文链接：https://blog.csdn.net/qq736572903/article/details/95309334

版权

本篇springboot集成：（spring+elasticjob在上篇 https://blog.csdn.net/qq736572903/article/details/95308218）

elasticjob监控：（建议去官网下载，自己打包部署就行，这下载需要积分）：https://blog.csdn.net/qq736572903/article/details/95310871

pom.xml:

<properties>
     <elastic-job.version>2.1.5</elastic-job.version>
</properties>

<!-- 当当网的elasticjob -->
<dependency>
     <groupId>com.dangdang</groupId>
     <artifactId>elastic-job-lite-core</artifactId>
     <version>${elastic-job.version}</version>
</dependency>
        
<dependency>
     <groupId>com.dangdang</groupId>
     <artifactId>elastic-job-lite-spring</artifactId>
     <version>${elastic-job.version}</version>
</dependency>

application.properties:

#elasticjob定时任务注册中心的配置
regCenter.serverList=192.168.0.102:2185
regCenter.namespace=dd-job
regCenter.base-sleep-time-milliseconds=1000
regCenter.max-sleep-time-milliseconds=3000
regCenter.max-retries=3
regCenter.connection-timeout-milliseconds=15000

#第一个定时任务
simpleJob.cron=0/20 * * * * ?
simpleJob.shardingTotalCount=3

#第二个定时任务
simpleJob2.cron=0/10 * * * * ?
simpleJob2.shardingTotalCount=3

#流定时任务
dataflowJob.cron=0/10 * * * * ?
dataflowJob.shardingTotalCount=3
#sharding-item-parameters用于指定与分片对应的别名
dataflowJob.shardingItemParameters=0=A,1=B,2=C

ElasticRegCenterConfig：zookeeper的配置

package com.demo.elasticjob.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;

@Configuration
public class ElasticRegCenterConfig {
    /**
     * 配置zookeeper
     *
     * @param serverList
     * @param namespace
     * @return
     */
    @Bean(initMethod = "init")
    public ZookeeperRegistryCenter regCenter(
            @Value("${regCenter.serverList}") final String serverList,
            @Value("${regCenter.namespace}") final String namespace,
            @Value("${regCenter.base-sleep-time-milliseconds}") final int baseSleepTimeMilliseconds,
            @Value("${regCenter.max-sleep-time-milliseconds}") final int maxSleepTimeMilliseconds,
            @Value("${regCenter.connection-timeout-milliseconds}") final int connectionTimeoutMilliseconds,
            @Value("${regCenter.max-retries}") final int maxRetries) {
    	
    	ZookeeperConfiguration zkConfiguration = new ZookeeperConfiguration(serverList, namespace);
    	//最大重试次数
    	zkConfiguration.setMaxRetries(maxRetries);
    	//连接超时时间
    	zkConfiguration.setConnectionTimeoutMilliseconds(connectionTimeoutMilliseconds);
    	//等待重试的间隔时间的初始值  单位：毫秒
    	zkConfiguration.setBaseSleepTimeMilliseconds(baseSleepTimeMilliseconds);
    	//等待重试的间隔时间的最大值
    	zkConfiguration.setMaxSleepTimeMilliseconds(maxSleepTimeMilliseconds);
    	
        return new ZookeeperRegistryCenter(zkConfiguration);
    }
}

SimpleJobConfig：如果需要配置多个定时任务，只要在里面加bean就好了

package com.demo.elasticjob.config;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.lite.spring.api.SpringJobScheduler;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;
import com.demo.elasticjob.SimpleElasticJob;
import com.demo.elasticjob.SimpleElasticJob2;

@Configuration
public class SimpleJobConfig {
	@Resource
	private ZookeeperRegistryCenter regCenter;
	
	/**
	 * 第一个simplejob
	 */
	@Bean
	public SimpleElasticJob simpleJob() {
		return new SimpleElasticJob();
	}

	@Bean(initMethod = "init")
	public JobScheduler simpleJobScheduler(final SimpleElasticJob simpleJob, @Value("${simpleJob.cron}") final String cron,
			@Value("${simpleJob.shardingTotalCount}") final int shardingTotalCount) {

		return new SpringJobScheduler(simpleJob, regCenter,
				getSimpleAJobConfiguration(simpleJob.getClass(), cron, shardingTotalCount));
	}
	
	/**
	 * 第二个simplejob
	 */
	@Bean
	public SimpleElasticJob2 simpleJob2() {
		return new SimpleElasticJob2();
	}
	
	@Bean(initMethod = "init")
	public JobScheduler simpleJobScheduler2(final SimpleElasticJob2 simpleJob, @Value("${simpleJob2.cron}") final String cron,
			@Value("${simpleJob2.shardingTotalCount}") final int shardingTotalCount) {

		return new SpringJobScheduler(simpleJob, regCenter,
				getSimpleAJobConfiguration(simpleJob.getClass(), cron, shardingTotalCount));
	}

	/**
	 * 简单定时任务
	 *
	 * @param jobClass
	 * @param cron
	 * @param shardingTotalCount
	 * @return
	 */
	private LiteJobConfiguration getSimpleAJobConfiguration(final Class<? extends SimpleJob> jobClass,
			final String cron, final int shardingTotalCount) {
		return LiteJobConfiguration.newBuilder(new SimpleJobConfiguration(
				JobCoreConfiguration.newBuilder(jobClass.getName(), cron, shardingTotalCount).build(),
				jobClass.getCanonicalName())).overwrite(true).build();
	}

}

DataflowJobConfig：数据流定时任务配置

package com.demo.elasticjob.config;

import com.dangdang.ddframe.job.api.dataflow.DataflowJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.dataflow.DataflowJobConfiguration;
import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.lite.spring.api.SpringJobScheduler;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;
import com.demo.elasticjob.DataFlowElasticJob;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * 流式任务配置
 */
@Configuration
public class DataflowJobConfig {
	// 注册中心配置
	@Resource
	private ZookeeperRegistryCenter regCenter;

	// 将作业运行的痕迹进行持久化到DB的操作配置
//	@Resource
//	private JobEventConfiguration jobEventConfiguration;

	@Bean
	public DataFlowElasticJob dataflowJob() {
		return new DataFlowElasticJob();
	}

	@Bean(initMethod = "init")
	public JobScheduler dataflowJobScheduler(final DataFlowElasticJob dataflowJob,
			@Value("${dataflowJob.cron}") final String cron,
			@Value("${dataflowJob.shardingTotalCount}") final int shardingTotalCount,
			@Value("${dataflowJob.shardingItemParameters}") final String shardingItemParameters) {
		return new SpringJobScheduler(dataflowJob, regCenter,
				getLiteJobConfiguration(dataflowJob.getClass(), cron, shardingTotalCount, shardingItemParameters));
//				jobEventConfiguration);
	}

	private LiteJobConfiguration getLiteJobConfiguration(final Class<? extends DataflowJob> jobClass, final String cron,
			final int shardingTotalCount, final String shardingItemParameters) {
		return LiteJobConfiguration
				.newBuilder(new DataflowJobConfiguration(
						JobCoreConfiguration.newBuilder(jobClass.getName(), cron, shardingTotalCount)
								.shardingItemParameters(shardingItemParameters).build(),
						jobClass.getCanonicalName(), true))
				.overwrite(true).build();
	}
}

DataFlowElasticJob：

package com.demo.elasticjob;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.dataflow.DataflowJob;

/**
 * elastic job 数据流定时任务
 */
public class DataFlowElasticJob implements DataflowJob<String>{
	
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	@Override
	public List<String> fetchData(ShardingContext context) {
		int item = context.getShardingItem();
		
		List<String> list = new ArrayList<String>();
		
		switch (item) {
		case 0:
			list.add("0");
			list.add("00");
			list.add("000");
			break;
		case 1:
			list.add("1");
			list.add("11");
			list.add("111");
			break;
		case 2:
			list.add("2");
			list.add("22");
			list.add("222");
			break;
		default:
			break;
		}
		
		return list;
	}

	@Override
	public void processData(ShardingContext context, List<String> list) {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
		}
		System.out.println("\n"+sdf.format(new Date()));
		System.out.println(String.format("当前分片:%d,list数据:%s,%s,%s",context.getShardingItem() , list.get(0), list.get(1), list.get(2)));
	}

}

SimpleElasticJob2：就放一个了，另一个不放了

package com.demo.elasticjob;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.demo.entity.OriginalBill;
import com.demo.service.IOriginalBillService;

/**
 * elastic job  简单的定时任务
 */
public class SimpleElasticJob2 implements SimpleJob{
	
    private static final Logger logger = LoggerFactory.getLogger(SimpleElasticJob2.class);
    
    @Autowired
    private IOriginalBillService originalService;
    
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
	@Override
	public void execute(ShardingContext shardingContext) {
//		System.out.println(sdf.format(new Date())+"第二个job");
		logger.info(String.format("第二个job日志打印：%s", shardingContext.getShardingItem()));
//		List<OriginalBill> list = originalService.getAllOriginalBill();
//		if(list == null || list.size() == 0){
//			return;
//		}
//		
//		for(int i=0; i<list.size(); i++){
			try {
				Thread.sleep(6000);
			} catch (InterruptedException e) {
			}
//			OriginalBill bill = list.get(i);
//			switchJob(shardingContext, bill);
//		}
		
	}

	private void switchJob(ShardingContext shardingContext, OriginalBill bill) {
		
		int shard = (int) (bill.getId()%3);
		if(shard == shardingContext.getShardingItem()){
			System.out.println("当前分片"+shardingContext.getShardingItem());
			
			bill.setLastUpdateUser(shard);
			originalService.updateOriginalBill(bill);
		}
		
//		switch (shardingContext.getShardingItem()) {
//        case 0: 
//            System.out.println("当前分片0："+shardingContext.getShardingItem());
//            break;
//        case 1: 
//        	System.out.println("当前分片1："+shardingContext.getShardingItem());
//            break;
//        case 2: 
//        	System.out.println("当前分片2："+shardingContext.getShardingItem());
//            break;
//		}
		 
	}
	 
	
}