使用rabbitmq时,保证消息的可靠性投递【三】

消息投递成功后,在数据库记录消息状态为成功,若没有投递成功,则消息还是初始状态投递中,此时启动定时任务获取数据库内消息状态为投递中的数据,再次投递;另外,为了防止在rabbitmq故障的情况下停止投递信息,限制重复投递的次数,例如3次,每次重复投递都要在数据库中更新重复投递次数。

  1. 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>
  1. 首先你需要配置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);
    }
}
  1. 需要一个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()
        );
    }
  1. 看一下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

评论

暂无评论