[GitHub] [shardingsphere-elasticjob] caojingui edited a comment on issue #1445: Support Annotation Job

[GitBox <gi...@apache.org>]

caojingui edited a comment on issue #1445:
URL: https://github.com/apache/shardingsphere-elasticjob/issues/1445#issuecomment-729669613


   ### simpleJob annotion definition 
   
   ```java
   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Component
   public @interface SimpleJob {
   
       /**
        * default: job.getClass().getCanonicalName()
        * @see JobCoreConfiguration#getJobName()
        */
       String name() default "";
   
       /**
        * support spring expression ${key}
        * @see JobCoreConfiguration#getCron()
        */
       String cron();
   
       /**
        * @see JobCoreConfiguration#getShardingTotalCount()
        */
       int shardingTotalCount() default 1;
   
       /**
        * support spring expression
        *
        * @see JobCoreConfiguration#getShardingItemParameters()
        */
       String shardingItemParameters() default "";
   
       /**
        * support spring expression
        *
        * @see JobCoreConfiguration#getJobParameter()
        */
       String jobParameters() default "";
   
       /**
        * @see LiteJobConfiguration#isOverwrite()
        */
       boolean overwrite() default false;
   
       /**
        * @see LiteJobConfiguration#isDisabled()
        */
       boolean disabled() default false;
   
       /**
        * @see LiteJobConfiguration#isMonitorExecution()
        */
       boolean monitorExecution() default true;
   
       /**
        * @see JobCoreConfiguration#isFailover()
        */
       boolean failover() default false;
   
       /**
        * @see JobCoreConfiguration#isMisfire()
        */
       boolean misfire() default true;
   
       /**
        * @see JobPropertiesEnum#JOB_EXCEPTION_HANDLER
        */
       String jobExceptionHandler() default "";
   
       /**
        * @see LiteJobConfiguration#getJobShardingStrategyClass()
        */
       String jobShardingStrategyClass() default "";
   
       /**
        * @see JobCoreConfiguration#getDescription()
        */
       String description() default "";
   }
   ```
   
   ### deal with BeanDefinitionRegistryPostProcessor
   
   ```java
   public class ElasticJobScannerConfigurer implements BeanDefinitionRegistryPostProcessor, BeanFactoryAware, EnvironmentAware {
       private final Logger logger = LoggerFactory.getLogger(getClass());
       private static final String registryCenterRef = "zookeeperRegistryCenter";
       private ConfigurableListableBeanFactory beanFactory;
       private Environment environment;
   
       /**
        * @see ZookeeperConfiguration#getNamespace()
        */
       private String namespace;
   
       /**
        * @see ZookeeperConfiguration#getServerLists()
        */
       private String serverList;
   
       private String defaultJobExceptionHandler = "com.dangdang.ddframe.job.executor.handler.impl.DefaultJobExceptionHandler";
       private String defaultJobShardingStrategyClass = "com.dangdang.ddframe.job.lite.api.strategy.impl.AverageAllocationJobShardingStrategy";
   
       public ElasticJobScannerConfigurer() {
       }
   
       @Override
       public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
       }
   
       @Override
       public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
           checkConfig();
           registryZookeeperConfigurationBeanDefinition(registry);
           for (String beanName : registry.getBeanDefinitionNames()) {
               Class clazz = beanFactory.getType(beanName);
               if (!SimpleJob.class.isAssignableFrom(clazz)) {
                   continue;
               }
   
               SimpleJob jobConfig = (SimpleJob) clazz.getAnnotation(SimpleJob.class);
               if (jobConfig == null) {
                   continue;
               }
   
               String jobName = clazz.getCanonicalName();
               if (!Strings.isNullOrEmpty(jobConfig.name())) {
                   jobName = jobConfig.name();
               }
               logger.info("register elasticJob jobName={}, jobClass={}, config={}", jobName, clazz.getCanonicalName(),
                       JSON.toJSONString(jobConfig));
   
               BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(SpringJobScheduler.class);
               factory.addConstructorArgReference(beanName);
               factory.addConstructorArgReference(registryCenterRef);
               factory.addConstructorArgValue(getLiteJobConfiguration(jobConfig, jobName, jobName));
               factory.addConstructorArgValue(BeanDefinitionBuilder.rootBeanDefinition(JobEventLogConfiguration.class).getBeanDefinition());
               factory.addConstructorArgValue(Lists.newArrayList());
   
               factory.setInitMethodName("init");
               factory.setDestroyMethodName("shutdown");
               registry.registerBeanDefinition(jobName, factory.getBeanDefinition());
           }
       }
   
       private void checkConfig() {
           if (Strings.isNullOrEmpty(namespace)) {
               throw new BeanCreationException("namespace can not be empty");
           }
           if (Strings.isNullOrEmpty(serverList)) {
               throw new BeanCreationException("serverList can not be empty");
           }
       }
   
       private void registryZookeeperConfigurationBeanDefinition(BeanDefinitionRegistry registry) {
           logger.info("register bean of ZookeeperRegistryCenter with namspace={}, srverList={}", namespace, serverList);
           BeanDefinitionBuilder configuration = BeanDefinitionBuilder.rootBeanDefinition(ZookeeperConfiguration.class);
           configuration.addConstructorArgValue(serverList);
           configuration.addConstructorArgValue(namespace);
   
           BeanDefinitionBuilder result = BeanDefinitionBuilder.rootBeanDefinition(ZookeeperRegistryCenter.class);
           result.addConstructorArgValue(configuration.getBeanDefinition());
           result.setInitMethodName("init");
           result.setDestroyMethodName("close");
           registry.registerBeanDefinition(registryCenterRef, result.getBeanDefinition());
       }
   
       private LiteJobConfiguration getLiteJobConfiguration(ElasticJobConfig config, String jobName, String jobClassName) {
   
           String cron = environment.resolvePlaceholders(config.cron());
           String jobExceptionHandler = config.jobExceptionHandler();
           if (Strings.isNullOrEmpty(jobExceptionHandler)) {
               jobExceptionHandler = defaultJobExceptionHandler;
           }
           String jobShardingStrategyClass = config.jobShardingStrategyClass();
           if (Strings.isNullOrEmpty(jobShardingStrategyClass)) {
               jobShardingStrategyClass = defaultJobShardingStrategyClass;
           }
   
           String jobParameters = config.jobParameters();
           if (!Strings.isNullOrEmpty(jobParameters)) {
               jobParameters = environment.resolvePlaceholders(jobParameters);
           }
   
   
           String shardingItemParameters = config.shardingItemParameters();
           if (!Strings.isNullOrEmpty(shardingItemParameters)) {
               shardingItemParameters = environment.resolvePlaceholders(shardingItemParameters);
           }
   
   
           JobCoreConfiguration coreConfiguration = JobCoreConfiguration.newBuilder(jobName, cron, config.shardingTotalCount())
                   .shardingItemParameters(shardingItemParameters)
                   .jobProperties(JobPropertiesEnum.JOB_EXCEPTION_HANDLER.getKey(), jobExceptionHandler)
                   .misfire(config.misfire())
                   .description(config.description())
                   .failover(config.failover())
                   .jobParameter(jobParameters)
                   .build();
   
           SimpleJobConfiguration jobConfiguration = new SimpleJobConfiguration(coreConfiguration, jobClassName);
   
           return LiteJobConfiguration.newBuilder(jobConfiguration)
                   .jobShardingStrategyClass(jobShardingStrategyClass)
                   .disabled(config.disabled())
                   .overwrite(config.overwrite())
                   .monitorExecution(config.monitorExecution())
                   .build();
       }
   
       @Override
       public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
       }
   
       @Override
       public void setEnvironment(Environment environment) {
           this.environment = environment;
       }
   
       public String getNamespace() {
           return namespace;
       }
   
       public void setNamespace(String namespace) {
           this.namespace = namespace;
       }
   
       public String getServerList() {
           return serverList;
       }
   
       public void setServerList(String serverList) {
           this.serverList = serverList;
       }
   
       public String getDefaultJobExceptionHandler() {
           return defaultJobExceptionHandler;
       }
   
       public void setDefaultJobExceptionHandler(String defaultJobExceptionHandler) {
           this.defaultJobExceptionHandler = defaultJobExceptionHandler;
       }
   
       public String getDefaultJobShardingStrategyClass() {
           return defaultJobShardingStrategyClass;
       }
   
       public void setDefaultJobShardingStrategyClass(String defaultJobShardingStrategyClass) {
           this.defaultJobShardingStrategyClass = defaultJobShardingStrategyClass;
       }
   }
   ```
   ### config  and use
   
   ```xml
   <bean class="com.dangdang.ddframe.job.lite.spring.configurer.ElasticJobScannerConfigurer">
       <property name="namespace" value="${ejob.zk.namespace}"/>
       <property name="serverList" value="${ejob.zk.url}"/>
   </bean>
   ```
   
   ```java
   @SimpleJob(cron = "0 0 10,14,16 * * ?")
   public class TestJob implements SimpleJob {
       @Override
       public void execute(ShardingContext shardingContext) {
           // todo
       }
   }
   ```
   
   ### other
   1. like this, defined @ScriptJob  @DataflowJob
   2. with spring Import  we can defined @EnableElasticJob  to replace config the ElasticJobScannerConfigurer
   
   


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org