com.cloud.task.handler.ScheduledTaskBeanProcessor Maven / Gradle / Ivy

package com.cloud.task.handler;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.core.env.Environment;
import org.springframework.util.StringUtils;

import com.cloud.task.annotation.ScheduledTask;
import com.cloud.task.constant.TaskConstants;
import com.cloud.task.listener.ManualScheduledTaskListener;
import com.cloud.task.model.ShutDownApplicationEvent;
import com.cloud.task.model.TaskScheduler;
import com.cloud.task.util.SpringUtil;
import com.dangdang.ddframe.job.api.ElasticJob;
import com.dangdang.ddframe.job.api.dataflow.DataflowJob;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.JobTypeConfiguration;
import com.dangdang.ddframe.job.config.dataflow.DataflowJobConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.executor.handler.JobProperties;
import com.dangdang.ddframe.job.lite.api.listener.ElasticJobListener;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;

/**
 *〈定时任务解析器〉
 
 *
 * @author number68
 * @date 2019/4/25
 * @since 0.1
 */
@Configuration
@Order(1)
public class ScheduledTaskBeanProcessor implements ApplicationListener {
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    private String prefix = "task.";

    @Autowired
    private ScheduledTaskBuilder scheduledTaskBuilder;

    @Autowired
    private Environment environment;

    @Autowired
    private ManualScheduledTaskListener manualScheduledTaskListener;

    @SuppressWarnings("unchecked")
    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        ConfigurableApplicationContext ctx = event.getApplicationContext();
        Map beanMap = ctx.getBeansWithAnnotation(ScheduledTask.class);
        List taskSchedulers = new ArrayList<>();
        try {
            for (Object confBean : beanMap.values()) {
                taskSchedulers.add(this.createTaskScheduler((ElasticJob)confBean, (Class)(confBean.getClass())));
            }
        } catch (Exception e) {
            closeApplication(ctx, e);
            return;
        }

        try {
            for (TaskScheduler taskScheduler : taskSchedulers) {
                log.info("【" + taskScheduler.getScheduledTask().name() + "】\tinit begin");
                taskScheduler.getSpringJobScheduler().init();
                log.info("【" + taskScheduler.getScheduledTask().name() + "】\tinit success");
            }
        } catch (Exception e) {
            closeApplication(ctx, e);
        }

        if (null != manualScheduledTaskListener) {
            manualScheduledTaskListener.monitorJob();
        }
    }

    private TaskScheduler createTaskScheduler(ElasticJob taskBean, Class taskClass) {
        ScheduledTask conf = taskClass.getAnnotation(ScheduledTask.class);
        String taskName = conf.name();
        String cron = this.getEnvironmentStringValue(taskName, TaskConstants.CRON, conf.cron());
        int shardingTotalCount =
                this.getEnvironmentIntValue(taskName, TaskConstants.SHARDING_TOTAL_COUNT, conf.shardingTotalCount());
        String shardingItemParameters =
            this.getEnvironmentStringValue(taskName, TaskConstants.SHARDING_ITEM_PARAMETERS, conf.shardingItemParameters());

        String description = this.getEnvironmentStringValue(taskName, TaskConstants.DESCRIPTION, conf.description());
        String jobParameter = this.getEnvironmentStringValue(taskName, TaskConstants.JOB_PARAMETER, conf.jobParameter());
        String jobExceptionHandler =
            this.getEnvironmentStringValue(taskName, TaskConstants.JOB_EXCEPTION_HANDLER, conf.jobExceptionHandler());
        String executorServiceHandler =
            this.getEnvironmentStringValue(taskName, TaskConstants.EXECUTOR_SERVICE_HANDLER, conf.executorServiceHandler());
        String jobShardingStrategyClass = this.getEnvironmentStringValue(taskName, TaskConstants.JOB_SHARDING_STRATEGY_CLASS,
            conf.jobShardingStrategyClass());
        String eventTraceRdbDataSource = this.getEnvironmentStringValue(taskName, TaskConstants.EVENT_TRACE_RDB_DATA_SOURCE,
            conf.eventTraceRdbDataSource());

        boolean failover = this.getEnvironmentBooleanValue(taskName, TaskConstants.FAILOVER, conf.failover());
        boolean misfire = this.getEnvironmentBooleanValue(taskName, TaskConstants.MISFIRE, conf.misfire());
        boolean overwrite = this.getEnvironmentBooleanValue(taskName, TaskConstants.OVERWRITE, conf.overwrite());
        boolean disabled = this.getEnvironmentBooleanValue(taskName, TaskConstants.DISABLED, conf.disabled());

        boolean monitorExecution =
            this.getEnvironmentBooleanValue(taskName, TaskConstants.MONITOR_EXECUTION, conf.monitorExecution());
        int monitorPort = this.getEnvironmentIntValue(taskName, TaskConstants.MONITOR_PORT, conf.monitorPort());

        boolean streamingProcess =
            this.getEnvironmentBooleanValue(taskName, TaskConstants.STREAMING_PROCESS, conf.streamingProcess());

        int maxTimeDiffSeconds =
            this.getEnvironmentIntValue(taskName, TaskConstants.MAX_TIME_DIFF_SECONDS, conf.maxTimeDiffSeconds());
        int reconcileIntervalMinutes =
            this.getEnvironmentIntValue(taskName, TaskConstants.RECONCILE_INTERVAL_MINUTES, conf.reconcileIntervalMinutes());

        // 核心配置
        JobCoreConfiguration coreConfig = JobCoreConfiguration.newBuilder(taskName, cron, shardingTotalCount)
            .shardingItemParameters(shardingItemParameters).description(description).failover(failover)
            .jobParameter(jobParameter).misfire(misfire)
            .jobProperties(JobProperties.JobPropertiesEnum.JOB_EXCEPTION_HANDLER.getKey(), jobExceptionHandler)
            .jobProperties(JobProperties.JobPropertiesEnum.EXECUTOR_SERVICE_HANDLER.getKey(), executorServiceHandler)
            .build();

        JobTypeConfiguration typeConfig = null;
        if (SimpleJob.class.isAssignableFrom(taskClass)) {
            typeConfig = new SimpleJobConfiguration(coreConfig, taskClass.getCanonicalName());
        } else if (DataflowJob.class.isAssignableFrom(taskClass)) {
            typeConfig = new DataflowJobConfiguration(coreConfig, taskClass.getCanonicalName(), streamingProcess);
        } else {
            String errorMsg = "Invalid task config, task name=" + taskName;
            throw new RuntimeException(errorMsg);
        }

        LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(typeConfig).overwrite(overwrite)
            .disabled(disabled).monitorPort(monitorPort).monitorExecution(monitorExecution)
            .maxTimeDiffSeconds(maxTimeDiffSeconds).jobShardingStrategyClass(jobShardingStrategyClass)
            .reconcileIntervalMinutes(reconcileIntervalMinutes).build();

        /**
         * 任务执行日志数据源，以名称获取(注意不是DataSource而是{@link com.dangdang.ddframe.job.event.JobEventConfiguration})

         * 如果为空就使用系统缺省的:由`com.cloud.task.config.ScheduledTaskConfig`自动创建的`defaultJobEventConfiguration`Bean,参见{@link com.cloud.task.config.JobEventRdbConfiguration}
         */
        JobEventConfiguration jobEventRdbConfiguration = null;
        if (StringUtils.hasLength(eventTraceRdbDataSource)) {
            jobEventRdbConfiguration = SpringUtil.getBean(eventTraceRdbDataSource, JobEventConfiguration.class);
        }

        List elasticJobListeners = getTargetElasticJobListeners(conf);
        return new TaskScheduler(
            scheduledTaskBuilder.buildScheduledTask(taskBean, jobConfig, jobEventRdbConfiguration, elasticJobListeners),
            conf);
    }

    private List getTargetElasticJobListeners(ScheduledTask conf) {
        List result = new ArrayList<>();
        String listener = this.getEnvironmentStringValue(conf.name(), TaskConstants.LISTENER, conf.listener());
        if (StringUtils.hasLength(listener)) {
            ElasticJobListener taskListener = SpringUtil.getBean(listener, ElasticJobListener.class);
            if (null != taskListener) {
                result.add(taskListener);
            }
        }

        String distributedListener =
            this.getEnvironmentStringValue(conf.name(), TaskConstants.DISTRIBUTED_LISTENER, conf.distributedListener());
        if (StringUtils.hasLength(distributedListener)) {
            ElasticJobListener distributedTaskListener =
                SpringUtil.getBean(distributedListener, ElasticJobListener.class);
            if (null != distributedTaskListener) {
                result.add(distributedTaskListener);
            }
        }
        return result;

    }

    /**
     * 获取配置中的任务属性值，environment没有就用注解中的值
     * @param jobName		任务名称
     * @param fieldName		属性名称
     * @param defaultValue  默认值
     * @return
     */
    private String getEnvironmentStringValue(String jobName, String fieldName, String defaultValue) {
        String key = prefix + jobName + "." + fieldName;
        String value = environment.getProperty(key);
        if (StringUtils.hasLength(value)) {
            return value;
        }
        return defaultValue;
    }

    private int getEnvironmentIntValue(String jobName, String fieldName, int defaultValue) {
        String key = prefix + jobName + "." + fieldName;
        String value = environment.getProperty(key);
        if (StringUtils.hasLength(value)) {
            return Integer.valueOf(value);
        }
        return defaultValue;
    }

    private long getEnvironmentLongValue(String jobName, String fieldName, long defaultValue) {
        String key = prefix + jobName + "." + fieldName;
        String value = environment.getProperty(key);
        if (StringUtils.hasLength(value)) {
            return Long.valueOf(value);
        }
        return defaultValue;
    }

    private boolean getEnvironmentBooleanValue(String jobName, String fieldName, boolean defaultValue) {
        String key = prefix + jobName + "." + fieldName;
        String value = environment.getProperty(key);
        if (StringUtils.hasLength(value)) {
            return Boolean.valueOf(value);
        }
        return defaultValue;
    }

    protected void closeApplication(ConfigurableApplicationContext ctx, Exception e) {
        ctx.publishEvent(new ShutDownApplicationEvent(ctx.getApplicationName(), ctx, e));
    }
}