使用rabbitmq时,保证消息的可靠性投递【三】
文章目录
消息投递成功后,在数据库记录消息状态为成功,若没有投递成功,则消息还是初始状态投递中,此时启动定时任务获取数据库内消息状态为投递中的数据,再次投递;另外,为了防止在rabbitmq故障的情况下停止投递信息,限制重复投递的次数,例如3次,每次重复投递都要在数据库中更新重复投递次数。
- elastic-job 配置 es-job是一种分布式事务,依赖于zookeeper,所以你需要一个zookeeper的服务,es-job 需要两个依赖
<elastic-job.version>2.1.4</elastic-job.version>
<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>- 首先你需要配置zookeeper的注册中心配置
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnExpression("'${zookeeper.address}'.length() > 0")
public class RegisterCenterConfig {
// 记住 此处要调用init初始化方法,init会启动与zk的连接
@Bean(initMethod = "init")
public ZookeeperRegistryCenter registryCenter(
// 最主要的配置就是 address-》ip:port
// 和 namespace
@Value("${zookeeper.address}") final String serverLists,
@Value("${zookeeper.namespace}") final String namespace,
@Value("${zookeeper.connectionTimeout}") final int connectionTimeout,
@Value("${zookeeper.sessionTimeout}") final int sessionTimeout,
@Value("${zookeeper.maxRetries}") final int maxRetries
) {
ZookeeperConfiguration zookeeperConfiguration = new ZookeeperConfiguration(serverLists, namespace);
zookeeperConfiguration.setConnectionTimeoutMilliseconds(connectionTimeout);
zookeeperConfiguration.setSessionTimeoutMilliseconds(sessionTimeout);
zookeeperConfiguration.setMaxRetries(maxRetries);
return new ZookeeperRegistryCenter(zookeeperConfiguration);
}
}- 需要一个SimpleJobConfig 用来配置简单任务;首先需要一个任务调度Bean。
@Bean(initMethod = "init")
public JobScheduler simpleJobScheduler(
final SimpleJob simpleJob,
@Value("${simpleJob.cron}") final String cron,
@Value("${simpleJob.shardingTotalCount}") final int shardingTotalCount,
@Value("${simpleJob.shardingItemParameters}") final String shardingItemParameters,
@Value("${simpleJob.jobParameter}") final String jobParameter,
@Value("${simpleJob.failover}") final boolean failover,
@Value("${simpleJob.monitorExecution}") final boolean monitorExecution,
@Value("${simpleJob.monitorPort}") final int monitorPort,
@Value("${simpleJob.maxTimeDiffSeconds}") final int maxTimeDiffSeconds,
@Value("${simpleJob.jobShardingStrategyClass}") final String jobShardingStrategyClass
) {
return new SpringJobScheduler(
simpleJob,
registryCenter,
getLitJobconfiguration(
simpleJob.getClass(),
cron,
shardingTotalCount,
failover,
jobParameter,
shardingItemParameters,
jobShardingStrategyClass,
monitorExecution,
monitorPort,
maxTimeDiffSeconds
),
jobEventConfiguration,
new SimpleJobListener()
);
}- 看一下SpringJobScheduler 的参数,按照参数再依次创建对象
public SpringJobScheduler(
ElasticJob elasticJob,
CoordinatorRegistryCenter regCenter,
LiteJobConfiguration jobConfig,
JobEventConfiguration jobEventConfig,
ElasticJobListener... elasticJobListeners
) {
super(regCenter, jobConfig, jobEventConfig, getTargetElasticJobListeners(elasticJobListeners));
this.elasticJob = elasticJob;
}4-1. ElasticJob elasticJob 实现 SimpleJob 接口,在 execute 方法中执行任务
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import org.springframework.stereotype.Component;
@Component
public class MySimpleJob implements SimpleJob {
// ShardingContext shardingContext 任务信息
@Override
public void execute(ShardingContext shardingContext) {
System.err.println("--------- 开始任务 MySimpleJob ---------");
}
}
4-2 CoordinatorRegistryCenter regCenter 即在第二步 实现的 zookeeperRegister
4-3 LiteJobConfiguration jobConfig 这里将配置的任务相关的属性,以及任务的类对象,这些属性值都由properties文件配置,或者从注解获取,此处用的是properties配置文件
private LiteJobConfiguration getLitJobconfiguration(
Class<? extends SimpleJob> jobClass,
String cron,
int shardingTotalCount,
boolean failover,
String jobParameter,
String shardingItemParameters,
String jobShardingStrategyClass,
boolean monitorExecution,
int monitorPort,
int maxTimeDiffSeconds
) {
JobCoreConfiguration jobCoreConfiguration = JobCoreConfiguration.newBuilder(jobClass.getName(), cron, shardingTotalCount)
.misfire(true)
.failover(failover)
.jobParameter(jobParameter)
.shardingItemParameters(shardingItemParameters)
.build();
SimpleJobConfiguration simpleJobConfiguration = new SimpleJobConfiguration(jobCoreConfiguration, jobClass.getCanonicalName());
/*
1. 创建LiteJobConfiguration 需要传入 JobTypeConfiguration 故而创建 SimpleJobConfiguration;
2. 创建SimpleJobConfiguration 需要传人 JobCoreConfiguration coreConfig, String jobClass,其中 jobClass 使用 jobClass.getCanonicalName()
3. 创建 JobCoreConfiguration 调用
public static Builder newBuilder(final String jobName, final String cron, final int shardingTotalCount) {
return new Builder(jobName, cron, shardingTotalCount);
}
*/
LiteJobConfiguration liteJobConfiguration = LiteJobConfiguration.newBuilder(simpleJobConfiguration)
.jobShardingStrategyClass(jobShardingStrategyClass)
.monitorExecution(monitorExecution)
.monitorPort(monitorPort)
.maxTimeDiffSeconds(maxTimeDiffSeconds)
.overwrite(true)
.build();
return liteJobConfiguration;
}4-3. 继续看 SpringJobScheduler 的参数,JobEventConfiguration jobEventConfig
用于任务事件跟踪
import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.event.rdb.JobEventRdbConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
@Configuration
public class JobEventConfig {
@Autowired
DataSource dataSource;
@Bean
public JobEventConfiguration jobEventConfiguration() {
return new JobEventRdbConfiguration(dataSource);
}
}4-4. 事件监听器
import com.alibaba.fastjson.JSON;
import com.dangdang.ddframe.job.executor.ShardingContexts;
import com.dangdang.ddframe.job.lite.api.listener.ElasticJobListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SimpleJobListener implements ElasticJobListener {
private static final Logger log = LoggerFactory.getLogger(SimpleJobListener.class);
@Override
public void beforeJobExecuted(ShardingContexts shardingContexts) {
log.info("-------------------beforeJobExecuted: {}", JSON.toJSONString(shardingContexts));
}
@Override
public void afterJobExecuted(ShardingContexts shardingContexts) {
log.info("-------------------afterJobExecuted: {}", JSON.toJSONString(shardingContexts));
}
}至此,事件调度器就创建完成,触发init方法,开始执行任务。
最后贴一下配置文件
zookeeper.address=192.168.205.13:2181
zookeeper.namespace=elastic-job
zookeeper.connectionTimeout=10000
zookeeper.sessionTimeout=10000
zookeeper.maxRetries=3
# 此处为 simplejob配置
simpleJob.cron=0/5 * * * * ?
simpleJob.shardingTotalCount=2
simpleJob.shardingItemParameters=0=beijing,1=shanghai
simpleJob.jobParameter=source1=public,source2=private
simpleJob.failover=true
simpleJob.monitorExecution=true
simpleJob.monitorPort=8889
simpleJob.maxTimeDiffSeconds=-1
simpleJob.jobShardingStrategyClass=com.dangdang.ddframe.job.lite.api.strategy.impl.AverageAllocationJobShardingStrategy
# 此处为数据流任务的配置
dataflowJob.cron=0/10 * * * * ?
dataflowJob.shardingTotalCount=2
dataflowJob.shardingItemParameters=0=Beijing,1=Shanghai
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论