概述

需求

在前面的博客《Java定时器演进过程和生产级分布式任务调度ElasticJob代码实战》中,我们已经熟悉ElasticJob分布式任务的应用,其核心实现为elasticjob-lite-spring-boot-starter,少量配置开箱即用;还有前面也有博客文档谈谈走进Spring Boot源码学习之路和浅谈入门,了解Spring Boot的原理,没看过伙伴可以先翻看下前面的文章。SpringBoot官网已经提供非常多的starter使用,然而今天我们就来模拟封装一个简易的分布式任务调度实现定时任务选主执行和故障自动转移的starter,本篇主要重心在于基于SpringBoot官网标准start封装的模板和步骤。

相关概念

  • 应用程序上下文

    在Spring应用程序中,应用程序上下文是组成应用程序的对象(或“bean”)的网络。它包含我们的Web控制器,服务,存储库以及我们的应用程序可能需要的任何(通常是无状态的)对象。

  • 配置

    使用注释@Configuration标注的类,扮演添加到应用程序上下文的bean工厂。它可能包含带注释的工厂方法,@Bean其返回值由Spring自动添加到应用程序上下文中。

    简而言之,Spring配置为应用程序上下文提供bean。

  • 自动配置

    自动配置是Spring自动发现的@Configuration类。只要该类位于在类路径classpath上,即可自动配置,并将配置的结果添加到应用程序上下文中。自动配置可以是有条件的,使得其激活取决于外部因素,例如具有特定值的特定配置参数。

  • 自动配置模块

    自动配置模块是包含自动配置类的Maven或Gradle模块。这样,我们就可以构建自动为应用程序上下文做贡献的模块,添加某个功能或提供对某个外部库的访问。我们在Spring Boot应用程序中使用它所要做的就是在我们的pom.xml或者包含它的依赖项build.gradle。

    Spring Boot团队大量使用此方法将Spring Boot与外部库集成。

  • Spring Boot Starter

    Spring Boot Starter是一个Maven或Gradle模块,其唯一目的是提供“使用某个功能”“开始”所需的所有依赖项。这通常意味着它是一个单独的pom.xml或build.gradle文件,包含一个或多个自动配置模块的依赖项以及可能需要的任何其他依赖项。在Spring Boot应用程序中,我们只需要包含此启动器Starter即可使用该功能。

制作starter基本步骤

  • 提供了一个配置类,该配置类定义了我们需要的对象的实例化过程;
  • 提供了一个spring.factories文件,包含了配置类的全限定名;
  • 将配置类和spring.factories文件打包为一个启动器starter;
  • 程序启动时通过加载starter.jar包的spring.factories文件信息,然后通过反射实例化文件里面的类。

SpringBoot启动简述

Spring Boot 在启动的时候会做这几件事情

  • Spring Boot 在启动时会去依赖的 Starter 包中寻找 resources/META-INF/spring.factories 文件,然后根据文件中配置的 Jar 包去扫描项目所依赖的 Jar 包。
  • 根据 spring.factories 配置加载 AutoConfigure 类。
  • 根据 @Conditional 注解的条件,进行自动配置并将 Bean 注入 Spring Context。

其实也就是 Spring Boot 在启动的时候,按照约定去读取 Spring Boot Starter 的配置信息,再根据配置信息对资源进行初始化,并注入到 Spring 容器中。这样 Spring Boot 启动完毕后,就已经准备好了一切资源,使用过程中直接注入对应 Bean 资源即可。

实践

创建项目

  • 首先建立light-job-spring-boot-starter-autoconfigure的空项目,然后在项目中添加light-job-spring-boot-starter-autoconfigure的Maven模块,这里的light-job-spring-boot-starter-autoconfigure模块则是实现简易的分布式任务调度。

  • 然后再新建一个专门作为依赖light-job-spring-boot-starter-autoconfigure模块空实现的maven模块,名称为light-job-spring-boot-starter,这个也是参考SpringBoot官网封装标准,具体可以看前面的文章如何说明spring-boot-starter-data-redis的官网实现。

autoconfigure实现

参考GitHub基于分布式任务实现的一些代码,这里核心主要是构建一个light-job自动装配配置文件读取类和一个light-job自动装配配置类。

light-job-spring-boot-starter-autoconfigure模块添加Pom依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5. <modelVersion>4.0.0</modelVersion>
  6. <parent>
  7. <groupId>org.springframework.boot</groupId>
  8. <artifactId>spring-boot-starter-parent</artifactId>
  9. <version>2.6.4</version>
  10. <relativePath/> <!-- lookup parent from repository -->
  11. </parent>
  12. <groupId>com.itxs</groupId>
  13. <artifactId>light-job-spring-boot-starter-autoconfigure</artifactId>
  14. <version>1.0</version>
  15. <packaging>jar</packaging>
  16. <name>light-job-spring-boot-starter-autoconfigure</name>
  17. <description>Demo project for Spring Boot</description>
  18. <properties>
  19. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  20. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  21. <jdk.version>1.8</jdk.version>
  22. <spring-boot.version>2.6.4</spring-boot.version>
  23. <zookeeper.version>3.4.6</zookeeper.version>
  24. <commons-lang3.version>3.4</commons-lang3.version>
  25. <quartz.version>2.3.2</quartz.version>
  26. </properties>
  27. <dependencies>
  28. <dependency>
  29. <groupId>org.springframework.boot</groupId>
  30. <artifactId>spring-boot-starter</artifactId>
  31. <scope>provided</scope>
  32. </dependency>
  33. <dependency>
  34. <groupId>org.springframework.boot</groupId>
  35. <artifactId>spring-boot-starter-web</artifactId>
  36. <scope>provided</scope>
  37. </dependency>
  38. <dependency>
  39. <groupId>org.springframework.boot</groupId>
  40. <artifactId>spring-boot-configuration-processor</artifactId>
  41. <optional>true</optional>
  42. </dependency>
  43. <dependency>
  44. <groupId>org.springframework</groupId>
  45. <artifactId>spring-tx</artifactId>
  46. <scope>provided</scope>
  47. </dependency>
  48. <dependency>
  49. <groupId>org.springframework</groupId>
  50. <artifactId>spring-context-support</artifactId>
  51. <scope>provided</scope>
  52. </dependency>
  53. <dependency>
  54. <groupId>javax.servlet</groupId>
  55. <artifactId>javax.servlet-api</artifactId>
  56. <scope>provided</scope>
  57. </dependency>
  58. <dependency>
  59. <groupId>org.apache.commons</groupId>
  60. <artifactId>commons-lang3</artifactId>
  61. <version>${commons-lang3.version}</version>
  62. </dependency>
  63. <dependency>
  64. <groupId>org.apache.zookeeper</groupId>
  65. <artifactId>zookeeper</artifactId>
  66. <version>${zookeeper.version}</version>
  67. <exclusions>
  68. <exclusion>
  69. <groupId>org.slf4j</groupId>
  70. <artifactId>slf4j-log4j12</artifactId>
  71. </exclusion>
  72. </exclusions>
  73. </dependency>
  74. <dependency>
  75. <groupId>com.google.code.gson</groupId>
  76. <artifactId>gson</artifactId>
  77. </dependency>
  78. <dependency>
  79. <groupId>org.quartz-scheduler</groupId>
  80. <artifactId>quartz</artifactId>
  81. <version>${quartz.version}</version>
  82. <scope>provided</scope>
  83. </dependency>
  84. <dependency>
  85. <groupId>org.quartz-scheduler</groupId>
  86. <artifactId>quartz-jobs</artifactId>
  87. <version>${quartz.version}</version>
  88. <scope>provided</scope>
  89. </dependency>
  90. </dependencies>
  91. </project>

创建LightJobProperties读取配置文件

  1. package com.itxs.lightjob.config;
  2. import com.itxs.lightjob.zk.ZKManager.KEYS;
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import java.util.HashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. @ConfigurationProperties(prefix = "light.job",ignoreInvalidFields = true)
  9. public class LightJobProperties {
  10. private String enabled;
  11. private String zkConnect;
  12. private String rootPath = "/light/job";
  13. private int zkSessionTimeout = 60000;
  14. private String zkUsername;
  15. private String zkPassword;
  16. private List<String> ipBlackList;
  17. private List<String> targetBean;
  18. private List<String> targetMethod;
  19. private List<String> cronExpression;
  20. private List<String> startTime;
  21. private List<String> period;
  22. private List<String> delay;
  23. private List<String> params;
  24. private List<String> type;
  25. private List<String> extKeySuffix;
  26. private List<String> beforeMethod;
  27. private List<String> afterMethod;
  28. private List<String> threadNum;
  29. public Map<String, String> getConfig(){
  30. Map<String, String> properties = new HashMap<String, String>();
  31. properties.put(KEYS.zkConnectString.key, zkConnect);
  32. if(StringUtils.isNotBlank(rootPath)){
  33. properties.put(KEYS.rootPath.key, rootPath);
  34. }
  35. if(zkSessionTimeout > 0){
  36. properties.put(KEYS.zkSessionTimeout.key, zkSessionTimeout+"");
  37. }
  38. if(StringUtils.isNotBlank(zkUsername)){
  39. properties.put(KEYS.userName.key, zkUsername);
  40. }
  41. if(StringUtils.isNotBlank(zkPassword)){
  42. properties.put(KEYS.password.key, zkPassword);
  43. }
  44. StringBuilder sb = new StringBuilder();
  45. if(ipBlackList != null && ipBlackList.size() > 0){
  46. for(String ip:ipBlackList){
  47. sb.append(ip).append(",");
  48. }
  49. sb.substring(0,sb.lastIndexOf(","));
  50. }
  51. properties.put(KEYS.ipBlacklist.key, sb.toString());
  52. return properties;
  53. }
  54. public String getEnabled() {
  55. return enabled;
  56. }
  57. public void setEnabled(String enabled) {
  58. this.enabled = enabled;
  59. }
  60. public String getZkConnect() {
  61. return zkConnect;
  62. }
  63. public void setZkConnect(String zkConnect) {
  64. this.zkConnect = zkConnect;
  65. }
  66. public String getRootPath() {
  67. return rootPath;
  68. }
  69. public void setRootPath(String rootPath) {
  70. this.rootPath = rootPath;
  71. }
  72. public int getZkSessionTimeout() {
  73. return zkSessionTimeout;
  74. }
  75. public void setZkSessionTimeout(int zkSessionTimeout) {
  76. this.zkSessionTimeout = zkSessionTimeout;
  77. }
  78. public String getZkUsername() {
  79. return zkUsername;
  80. }
  81. public void setZkUsername(String zkUsername) {
  82. this.zkUsername = zkUsername;
  83. }
  84. public String getZkPassword() {
  85. return zkPassword;
  86. }
  87. public void setZkPassword(String zkPassword) {
  88. this.zkPassword = zkPassword;
  89. }
  90. public List<String> getIpBlackList() {
  91. return ipBlackList;
  92. }
  93. public void setIpBlackList(List<String> ipBlackList) {
  94. this.ipBlackList = ipBlackList;
  95. }
  96. public List<String> getTargetBean() {
  97. return targetBean;
  98. }
  99. public void setTargetBean(List<String> targetBean) {
  100. this.targetBean = targetBean;
  101. }
  102. public List<String> getTargetMethod() {
  103. return targetMethod;
  104. }
  105. public void setTargetMethod(List<String> targetMethod) {
  106. this.targetMethod = targetMethod;
  107. }
  108. public List<String> getCronExpression() {
  109. return cronExpression;
  110. }
  111. public void setCronExpression(List<String> cronExpression) {
  112. this.cronExpression = cronExpression;
  113. }
  114. public List<String> getStartTime() {
  115. return startTime;
  116. }
  117. public void setStartTime(List<String> startTime) {
  118. this.startTime = startTime;
  119. }
  120. public List<String> getPeriod() {
  121. return period;
  122. }
  123. public void setPeriod(List<String> period) {
  124. this.period = period;
  125. }
  126. public List<String> getDelay() {
  127. return delay;
  128. }
  129. public void setDelay(List<String> delay) {
  130. this.delay = delay;
  131. }
  132. public List<String> getParams() {
  133. return params;
  134. }
  135. public void setParams(List<String> params) {
  136. this.params = params;
  137. }
  138. public List<String> getType() {
  139. return type;
  140. }
  141. public void setType(List<String> type) {
  142. this.type = type;
  143. }
  144. public List<String> getExtKeySuffix() {
  145. return extKeySuffix;
  146. }
  147. public void setExtKeySuffix(List<String> extKeySuffix) {
  148. this.extKeySuffix = extKeySuffix;
  149. }
  150. public List<String> getBeforeMethod() {
  151. return beforeMethod;
  152. }
  153. public void setBeforeMethod(List<String> beforeMethod) {
  154. this.beforeMethod = beforeMethod;
  155. }
  156. public List<String> getAfterMethod() {
  157. return afterMethod;
  158. }
  159. public void setAfterMethod(List<String> afterMethod) {
  160. this.afterMethod = afterMethod;
  161. }
  162. public List<String> getThreadNum() {
  163. return threadNum;
  164. }
  165. public void setThreadNum(List<String> threadNum) {
  166. this.threadNum = threadNum;
  167. }
  168. }

创建自动装配类LightJobAutoConfiguration.java

  1. package com.itxs.lightjob.config;
  2. import com.itxs.lightjob.ZKScheduleManager;
  3. import com.itxs.lightjob.core.TaskDefine;
  4. import com.itxs.lightjob.util.ScheduleUtil;
  5. import org.apache.commons.lang3.StringUtils;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  10. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.ComponentScan;
  13. import org.springframework.context.annotation.Configuration;
  14. import java.text.ParseException;
  15. import java.util.ArrayList;
  16. import java.util.Date;
  17. import java.util.List;
  18. @Configuration
  19. @EnableConfigurationProperties({LightJobProperties.class})
  20. @ConditionalOnProperty(value = "light.job.enabled", havingValue = "true")
  21. @ComponentScan()
  22. public class LightJobAutoConfiguration {
  23. private static final Logger LOGGER = LoggerFactory.getLogger(LightJobAutoConfiguration.class);
  24. @Autowired
  25. private LightJobProperties uncodeScheduleConfig;
  26. @Bean(name = "zkScheduleManager", initMethod="init")
  27. public ZKScheduleManager commonMapper(){
  28. ZKScheduleManager zkScheduleManager = new ZKScheduleManager();
  29. zkScheduleManager.setZkConfig(uncodeScheduleConfig.getConfig());
  30. List<TaskDefine> list = initAllTask();
  31. zkScheduleManager.setInitTaskDefines(list);
  32. LOGGER.info("=====>ZKScheduleManager inited..");
  33. return zkScheduleManager;
  34. }
  35. private List<TaskDefine> initAllTask(){
  36. List<TaskDefine> list = new ArrayList<TaskDefine>();
  37. int total = 0;
  38. if(uncodeScheduleConfig.getTargetBean() != null){
  39. total = uncodeScheduleConfig.getTargetBean().size();
  40. }
  41. for(int i = 0; i < total; i++){
  42. TaskDefine taskDefine = new TaskDefine();
  43. if(uncodeScheduleConfig.getTargetBean() != null){
  44. String value = uncodeScheduleConfig.getTargetBean().get(i);
  45. if(StringUtils.isNotBlank(value)){
  46. taskDefine.setTargetBean(value);
  47. }
  48. }
  49. if(uncodeScheduleConfig.getTargetMethod() != null){
  50. String value = uncodeScheduleConfig.getTargetMethod().get(i);
  51. if(StringUtils.isNotBlank(value)){
  52. taskDefine.setTargetMethod(value);
  53. }
  54. }
  55. if(uncodeScheduleConfig.getCronExpression() != null){
  56. String value = uncodeScheduleConfig.getCronExpression().get(i);
  57. if(StringUtils.isNotBlank(value)){
  58. taskDefine.setCronExpression(value);
  59. }
  60. }
  61. if(uncodeScheduleConfig.getStartTime() != null){
  62. String value = uncodeScheduleConfig.getStartTime().get(i);
  63. if(StringUtils.isNotBlank(value)){
  64. Date time = null;
  65. try {
  66. time = ScheduleUtil.transferStringToDate(value);
  67. } catch (ParseException e) {
  68. e.printStackTrace();
  69. }
  70. if(time != null){
  71. taskDefine.setStartTime(time);
  72. }
  73. }
  74. }
  75. if(uncodeScheduleConfig.getPeriod() != null){
  76. String value = uncodeScheduleConfig.getPeriod().get(i);
  77. if(StringUtils.isNotBlank(value)){
  78. taskDefine.setPeriod(Long.valueOf(value));
  79. }
  80. }
  81. if(uncodeScheduleConfig.getDelay() != null){
  82. String value = uncodeScheduleConfig.getDelay().get(i);
  83. if(StringUtils.isNotBlank(value)){
  84. taskDefine.setDelay(Long.valueOf(value));
  85. }
  86. }
  87. if(uncodeScheduleConfig.getParams() != null){
  88. String value = uncodeScheduleConfig.getParams().get(i);
  89. if(StringUtils.isNotBlank(value)){
  90. taskDefine.setParams(value);
  91. }
  92. }
  93. if(uncodeScheduleConfig.getType() != null){
  94. String value = uncodeScheduleConfig.getType().get(i);
  95. if(StringUtils.isNotBlank(value)){
  96. taskDefine.setType(value);
  97. }
  98. }
  99. if(uncodeScheduleConfig.getExtKeySuffix() != null){
  100. String value = uncodeScheduleConfig.getExtKeySuffix().get(i);
  101. if(StringUtils.isNotBlank(value)){
  102. taskDefine.setExtKeySuffix(value);
  103. }
  104. }
  105. if(uncodeScheduleConfig.getBeforeMethod() != null){
  106. String value = uncodeScheduleConfig.getBeforeMethod().get(i);
  107. if(StringUtils.isNotBlank(value)){
  108. taskDefine.setBeforeMethod(value);
  109. }
  110. }
  111. if(uncodeScheduleConfig.getAfterMethod() != null){
  112. String value = uncodeScheduleConfig.getAfterMethod().get(i);
  113. if(StringUtils.isNotBlank(value)){
  114. taskDefine.setAfterMethod(value);
  115. }
  116. }
  117. if(uncodeScheduleConfig.getThreadNum() != null){
  118. String value = uncodeScheduleConfig.getThreadNum().get(i);
  119. if(StringUtils.isNotBlank(value)){
  120. taskDefine.setThreadNum(Integer.valueOf(value));
  121. }
  122. }
  123. list.add(taskDefine);
  124. }
  125. return list;
  126. }
  127. }

然后在resources目录下的META-INF目录下创建spring.factories文件,跟SpringBoot其他starter一样,输出自动装配类的全类名;springboot项目默认只会扫描本项目下的带@Configuration注解的类,如果自定义starter,不在本工程中,是无法加载的,所以要配置META-INF/spring.factories配置文件。配置了META-INF/spring.factories配置文件是springboot实现starter的关键点,springboot的这种配置加载方式是一种类SPI(Service Provider Interface)的方式,SPI可以在META-INF/services配置接口扩展的实现类,springboot中原理类似,只是名称换成了spring.factories而已。

  1. # Auto Configure
  2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  3. com.itxs.lightjob.config.LightJobAutoConfiguration

其他还有自动装配类的具体实现代码文件,如下面目录,主要利用zookeeper做分布式协调如分布式选主,执行maven install打包和安装到本地maven仓库。

light-job-spring-boot-starter

light-job-spring-boot-starter是不做实现,主要管理依赖,Pom文件内容如下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5. <modelVersion>4.0.0</modelVersion>
  6. <groupId>com.itxs</groupId>
  7. <artifactId>light-job-spring-boot-starter</artifactId>
  8. <version>1.0</version>
  9. <packaging>jar</packaging>
  10. <properties>
  11. <maven.compiler.source>8</maven.compiler.source>
  12. <maven.compiler.target>8</maven.compiler.target>
  13. </properties>
  14. <dependencies>
  15. <dependency>
  16. <groupId>com.itxs</groupId>
  17. <artifactId>light-job-spring-boot-starter-autoconfigure</artifactId>
  18. <version>1.0</version>
  19. </dependency>
  20. </dependencies>
  21. </project>

最后我们执行maven install打包和安装到本地maven仓库。

调用示例

示例工程中加入light-job-spring-boot-starter依赖,这里选择前面文章示例的库存微服务模块中添加

  1. <dependency>
  2. <groupId>com.itxs</groupId>
  3. <artifactId>light-job-spring-boot-starter</artifactId>
  4. <version>1.0</version>
  5. </dependency>

创建演示任务并放到Spring容器里管理

  1. package cn.itxs.ecom.storage.job;
  2. import org.springframework.stereotype.Component;
  3. @Component
  4. public class DemoTask {
  5. public void execute() {
  6. System.out.println("===========execute start!=========");
  7. System.out.println("===========do job!=========");
  8. System.out.println("===========execute end !=========");
  9. }
  10. }

配置文件增加

  1. light:
  2. job:
  3. enabled: true
  4. zk-connect: 192.168.4.27:2181,192.168.4.28:2181,192.168.4.29:2181
  5. root-path: /ecom/storage
  6. zk-session-timeout: 60000
  7. target-bean:
  8. - demoTask
  9. target-method:
  10. - execute
  11. period:
  12. - 1000
  13. cron-expression:
  14. - 0/10 * * * * ?

启动三个库存微服务模块,在第1个库存微服务模块看到demoTask任务已经根据配置每十秒在运行

关闭第1个库存微服务模块程序后,通过zookeeper重新选举一个节点定时执行,从下面看选择第3个库存微服务模块每十秒实行

Redis读取配置赋值lightjob

zookeeper地址配置可以放到配置中心如Nacos,如果目前我们配置数据是放在Redis中,可以通过System.setProperty设置系统变量的方式来实现,先注释zk-connect的配置,这是启动程序就会报错

RedisConfig配置类中增加实现BeanPostProcessor接口实现其postProcessAfterInitialization方法,在bean初始化后读取redis值设置环境变量值。

  1. package cn.itxs.ecom.storage.config;
  2. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  3. import com.fasterxml.jackson.annotation.PropertyAccessor;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.beans.BeansException;
  8. import org.springframework.beans.factory.config.BeanPostProcessor;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. @Configuration
  16. @Slf4j
  17. public class RedisConfig implements BeanPostProcessor{
  18. @Bean
  19. public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  20. RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
  21. template.setConnectionFactory(redisConnectionFactory);
  22. Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  23. ObjectMapper om = new ObjectMapper();
  24. om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  25. //om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance , ObjectMapper.DefaultTyping.NON_FINAL);
  26. jackson2JsonRedisSerializer.setObjectMapper(om);
  27. StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  28. // key采用String的序列化方式
  29. template.setKeySerializer(stringRedisSerializer);
  30. // hash的key也采用String的序列化方式
  31. template.setHashKeySerializer(stringRedisSerializer);
  32. // value序列化方式采用jackson
  33. //template.setValueSerializer(jackson2JsonRedisSerializer);
  34. template.setValueSerializer(stringRedisSerializer);
  35. // hash的value序列化方式采用jackson
  36. //template.setHashValueSerializer(jackson2JsonRedisSerializer);
  37. template.setHashValueSerializer(stringRedisSerializer);
  38. template.afterPropertiesSet();
  39. return template;
  40. }
  41. @Override
  42. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
  43. {
  44. //在redisTemplate Bean初始化之后设置light.job.zk-connect为公共集群的zk地址
  45. if (beanName.equals("redisTemplate")){
  46. log.info("postProcessAfterInitialization match beanName {}",beanName);
  47. try {
  48. RedisTemplate redisObj = (RedisTemplate) bean;
  49. String zkConnect = (String)redisObj.opsForHash().get("clusterinfo", "zookeeper-server");
  50. if (StringUtils.isNotBlank(zkConnect)) {
  51. log.info("postProcessAfterInitialization get zkConnect ={}", zkConnect);
  52. System.setProperty("light.job.zk-connect", zkConnect);
  53. log.info("System.setProperty light.job.zk-connect={}", zkConnect);
  54. }
  55. } catch (Exception e) {
  56. log.error("postProcessAfterInitialization operate redisTemplate {} failed", e);
  57. }
  58. }
  59. return null;
  60. }
  61. }

启动后可以看到正常每十秒执行定时任务

**本人博客网站 **IT小神 www.itxiaoshen.com

SpringBoot自定义starter开发分布式任务调度实践的更多相关文章

  1. SpringBoot --- 自定义 Starter

    SpringBoot --- 自定义 Starter 创建 1.需要创建一个新的空工程 2.新的工程需要引入两个模块 一个Maven 模块 作为启动器 一个SpringBoot 模块 作为自动配置模块 ...

  2. SpringBoot自定义starter及自动配置

    SpringBoot的核心就是自动配置,而支持自动配置的是一个个starter项目.除了官方已有的starter,用户自己也可以根据规则自定义自己的starter项目. 自定义starter条件 自动 ...

  3. SpringBoot自定义Starter实现

    自定义Starter: Starter会把所有用到的依赖都给包含进来,避免了开发者自己去引入依赖所带来的麻烦.Starter 提供了一种开箱即用的理念,其中核心就是springboot的自动配置原理相 ...

  4. springboot 自定义starter之AutoConfiguration【原】

    八.自定义starter AutoConfiguration: 1.这个场景需要使用到的依赖是什么? 没有特别依赖的配置 2.如何编写自动配置 @Configuration //指定这个类是一个配置类 ...

  5. Spring-Boot自定义Starter实践

    此文已由作者王慎为授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. disconf-spring-boot-starter 使用方法: 引入maven依赖: <depen ...

  6. SpringBoot系列三:SpringBoot自定义Starter

    在前面两章 SpringBoot入门 .SpringBoot自动配置原理 的学习后,我们对如何创建一个 SpringBoot 项目.SpringBoot 的运行原理以及自动配置等都有了一定的了解.如果 ...

  7. springboot自定义starter

    1,创建一个空工程 2,new一个Modules  ---------------- maven (启动器) : springboottest-spring-boot-starter 3,new一个M ...

  8. Springboot自定义starter打印sql及其执行时间

    前面写到了通过实现mybatis提供的org.apache.ibatis.plugin.Interceptor接口实现了打印SQL执行时间,并格式化SQL及其参数,如果我们使用的是ssm还得再配置文件 ...

  9. SpringBoot系列之自定义starter实践教程

    SpringBoot系列之自定义starter实践教程 Springboot是有提供了很多starter的,starter翻译过来可以理解为场景启动器,所谓场景启动器配置了自动配置等等对应业务模块的一 ...

随机推荐

  1. Bugku CTF练习题---加密---ok

    Bugku CTF练习题---加密---ok flag:flag{ok-ctf-1234-admin} 解题步骤: 1.观察题目,发现规律 2.发现所有内容都是ook写的, 直接上网搜索一下原因,发现 ...

  2. XCTF练习题---MISC---坚持60S

    XCTF练习题---MISC---坚持60S flag:flag{DajiDali_JinwanChiji} 解题步骤: 1.观察题目,下载附件,是一个java文件 2.打开玩了一会,真鸡儿难,试着反 ...

  3. Python 树表查找_千树万树梨花开,忽如一夜春风来(二叉排序树、平衡二叉树)

    什么是树表查询? 借助具有特殊性质的树数据结构进行关键字查找. 本文所涉及到的特殊结构性质的树包括: 二叉排序树. 平衡二叉树. 使用上述树结构存储数据时,因其本身对结点之间的关系以及顺序有特殊要求, ...

  4. 初探webpack之编写loader

    初探webpack之编写loader loader加载器是webpack的核心之一,其用于将不同类型的文件转换为webpack可识别的模块,即用于把模块原内容按照需求转换成新内容,用以加载非js模块, ...

  5. SpringBoot从0到0.7——序言

    SpringBoot从0到0.7-- 序言 最近做java代码审计发现很多地方看不懂,所以就开始学框架,自己做网站来了解网站的运行原理.函数.接口.参数等等,通过学习SpringBoot框架来从点到面 ...

  6. ElasticSearch7.3学习(二十五)----Doc value、query phase、fetch phase解析

    1.Doc value 搜索的时候,要依靠倒排索引: 排序的时候,需要依靠正排索引,看到每个document的每个field,然后进行排序. 所谓的正排索引,其实就是doc values. 在建立索引 ...

  7. GitHub 毕业年鉴「GitHub 热点速览 v.22.20」

    GitHub 毕业需要什么呢?一个 PR!那么提交一个 PR 需要什么?也许你是使用终端命令来提交 git 操作的,那么你可以了解下 Bash-Oneliner,收录了大量好用的 bash 命令,虽然 ...

  8. Redis设计与实现2.1:数据库和事件

    数据库和事件 这是<Redis设计与实现>系列的文章,系列导航:Redis设计与实现笔记 数据库 数据库的结构定义在 redis.h/redisServer 这个结构体中,这个结构体有许多 ...

  9. ArcGIS和ArcEngine导出地图时,png格式支持背景透明

    1.ArcGIS支持导出PNG,背景透明 导出png时,背景色和透明色不能设置为空,必须设置为同一个颜色,通常使用白色. 2.ArcEngine支持导出PNG,背景透明 //1.创建export IE ...

  10. DeepPrivacy: A Generative Adversarial Network for Face Anonymization阅读笔记

    DeepPrivacy: A Generative Adversarial Network for Face Anonymization ISVC 2019 https://arxiv.org/pdf ...