使用Nacos轻松实现分布式单点定时任务方式

    <dependency>
      <groupId>com.alibaba.nacos</groupId>
      <artifactId>nacos-client</artifactId>
      <version>${nacos.version}</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>dubbo-registry-nacos</artifactId>
      <version>${dubbo.version}</version>
    </dependency>

@Component
@Slf4j
public class DistributedTask implements ApplicationContextAware {

  	/**
  	* 应用运行端口
  	*/
    @Value("${dubbo.protocol.port}")
    private Integer serverPort;

    /**
  	* nacos注册中心地址
  	*/
    @Value("${nacos.server-address}")
    private String serverAddress;

    /**
  	* nacos注册中心端口
  	*/
    @Value("${nacos.port}")
    private String nacosPort;

    /**
  	* 分布式task服务名
  	*/
    private static final String SERVICENAME="distributedTask";

    /**
  	* Nacos命名服务，此处为静态对象
  	*/
    public static NamingService naming;

    /**
    * 应用程序上下文，随容器启动
    */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        try {
            if (naming==null) {
                //初始化Nacos命名服务
                naming = NamingFactory.createNamingService(serverAddress+":"+nacosPort);
                //设置服务实例
                Instance instance=new Instance();
                //获取IP，NetUtils是Dubbo源码里获取IP的
                instance.setIp(NetUtils.getLocalHost());
                instance.setPort(serverPort);
                //负载核心思想，记录当前运行时间戳，写入到服务元数据中
                instance.setMetadata(MapUtil.of("timestamp",System.currentTimeMillis()+""));
                //注册实例
                naming.registerInstance(DistributedTask.SERVICENAME,instance);
            }
        } catch (NacosException e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }
}

@Configuration
@Slf4j
//开启定时任务，通常写在项目启动类上
@EnableScheduling
public class AutoSubmitTask {

    @Autowired
    private DistributedTask distributedTask;

    /**
    * Dubbo远端服务，真实业务逻辑运行服务
    */
    @DubboReference(group = "nx")
    private ILogicService iLogicService;

    //标记当前是否正在运行
    private boolean currentRun=false;

    //调度规则
    @Scheduled(fixedRate = 1000)
    private void configureTasks() {
        //判断当前是否已经在本机运行job
        if(currentRun){
            //有则运行
            run();
        }else{
            //没有则判断是否需要运行，具体实现看集群容错算法章节
            if (distributedTask.isRunInCurrent()) {
                currentRun=true;
                run();
            }
        }
    }

    private void run(){
        log.info("执行PaperSubmitTask定时任务: " + LocalDateTime.now());
        iLogicService.autoSubmit();
    }
}

public class DistributedTask implements ApplicationContextAware {
    /**
    * 是否在当前应用中运行
    */
		public boolean isRunInCurrent(){
        try {
            //通过简单的算法得出应该运行的实例
            Instance instance = findInstance();
            //当前环境对于应该运行的实例
            if (instance!=null && instance.getIp().equals(NetUtils.getLocalHost()) && instance.getPort()==serverPort) {
                return true;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return false;
    }
    
    /**
    * 获取定时任务所在实例
    */
    private Instance findInstance(){
        Instance instance=null;
        try {
            //通过api获取定时任务服务的所有运行实例
            List<Instance> allInstances = naming.getAllInstances(SERVICENAME);
            if (CollectionUtils.isNotEmpty(allInstances)) {
                //通过运行时间戳排序，获取所有实例中最先运行的实例为真实运行实例
                allInstances.sort(Comparator.comparing((Instance a) -> a.getMetadata().get("timestamp")));
                instance=allInstances.get(0);
                log.debug("distributed task run in host:{},port:{}",instance.getIp(),instance.getPort());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }
}