一种退避序列实现

介绍功能和需求背景
介绍代码上下文，思路，方案。 
讲解代码，评委穿插提问。参会的其他同学有问题也可以提。 
评委对代码给建议和反馈

写在前面

         你有一个苹果，我有一个苹果，交换一下我们还是只有一个苹果；你有一本书，我有一本书，交换一下我们就有两本书了。每个程序员都有自己的工具集和代码私库，如果大家一起贡献出来，我们就会有一套较完整的工具集，相信可以解决大部分问题。

         作为一个程序员，一个工科生，现实中的理想就是有一套趁手的完整的工具套件，家里有点什么事情，只要拿出我的工具套件就能自己轻松搞定。跟现实中一样，我们中间件团队也在默默的打造自己的软件工具套件，也希望更多的同学一起来打造这一套称心的软件工具套件。

一、需求背景

1.1 业务需求

1.1.1 Nebulax流程实例保存失败重试和告警

流程执行完后会将流程实例调用http接口上报到星云服务端，若星云服务端不可用，不会发起重试，导致流程虽然执行完成，但是在控制台查看不到对应流程实例信息。- 改造成上报失败按(指数退避算法)策略，在一段时间后重试，确保流程实例能够上传到服务端
- 若上传失败，在尝试若干次后记录日志并发送告警给对应业务负责人

1.1.2 模拟MetaQ失败退避算法

网关应用原先依赖MetaQ,改造升级后内部的重试策略也是继承一致的重试策略，按固定级别(1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h)退避。

1.1.3 延迟调度平台重试策略优化

  • 发送消息时设置重试策略，目前支持两种重试策略

1、【普通模式】：默认模式，强烈建议用该模式，该模式间隔会逐步递增（5s，10s，30s，60s... 逐渐递增，总周期为7天，总共20次）。

2、【表达式模式】：

距离上次重试的时间间隔 = 首次重试间隔 + 已重试次数 * 重试时间间隔步长 * 首次重试间隔（秒）

在表达式模式的策略下，最大重试、首次重试间隔和步长才会生效。注意普通模式下，以下参数不生效。

​

  • 调度限流重试策略

  1. 主动限流使用随机数，5~15分钟

jobDetail.setRedoIntervalMode(RedoIntervalModeConstant.EXPRESSION);
// 最大重试次数,默认99次 
jobDetail.setFailRedoCountMax(10);
// 首次重试间隔(秒)
jobDetail.setFailFirstRedoInterval(5);
// 重试时间间隔步长，如设置成0，则每次重试间隔相同，如设置成1，则间隔是5、10、15...
jobDetail.setFailRedoIntervalStep(0);

​

1.2 需求整理

  • 根据策略获取下一次重试间隔

  • 根据策略获取指定次数的重试间隔

  • 多种退避算法，如指数退避、固定步长、等差数列、自定义固定级别退避，以及不退避。

  • 可以设置最大重试间隔，如最大重试间隔不能超过1小时

  • 可以设置最大重试次数，如最大重试20次

  • 可以获取当前重试次数，即已经执行了几次

  • 可以获取从开始到当前流逝的全部时间

  • 可以获取从开始到指定次数流逝的全部时间

  • 标准化重试策略和接口，方便延迟调度平台使用

​

​

二 方案调研

2.1 Guava实现

<dependency><groupId>com.github.rholder</groupId><artifactId>guava-retrying</artifactId><version>1.0.6</version>
</dependency>

详见: guava-retrying by rholder

2.2 Spring实现

<dependency> <groupId>org.springframework</groupId>  <artifactId>spring-core</artifactId> <version>4.3.17.RELEASE<version>
</dependency> 

public interface BackOff {/*** Start a new back off execution.* @return a fresh {@link BackOffExecution} ready to be used*/BackOffExecution start();}
package org.springframework.util.backoff;/*** Represent a particular back-off execution.** <p>Implementations do not need to be thread safe.** @author Stephane Nicoll* @since 4.1* @see BackOff*/
public interface BackOffExecution {/*** Return value of {@link #nextBackOff()} that indicates that the operation* should not be retried.*/long STOP = -1;/*** Return the number of milliseconds to wait before retrying the operation* or {@link #STOP} ({@value #STOP}) to indicate that no further attempt* should be made for the operation.*/long nextBackOff();}

三、我们的方案

2.2.1 基于Spring实现扩展

package com.xxx.commons.retry.backoff;/*** @created 2021-12-20 4:26 PM* @description:*/
public interface Backoff {/*** 开始** @return*/BackoffExecution start();}
package com.xxx.commons.retry.backoff;import java.util.concurrent.TimeUnit;/*** @created 2021-12-20 4:26 PM* @description:*/
public interface BackoffExecution {/*** 不再重试时返回的值*/long STOP = -1;/*** The default time unit*/TimeUnit DEFAULT_TIME_UNIT = TimeUnit.MILLISECONDS;/*** 下一次退避时间** @return nextBackoff 下一次重试延迟时间(毫秒)，不再重试时返回{@link #STOP} ({@value #STOP})*/long nextBackoff();/*** 根据重试次数获取指定次数的退避时间** @param attempt* @return*/long getBackoff(int attempt);/*** 从开始到现在一共经过的时间** @return*/long getElapsedTime();/*** 从开始到指定次数一共经过的时间** @param attempt* @return*/long getElapsedTime(int attempt);/*** 当前尝试次数** @return currentAttempt*/int currentAttempt();}

2.2.2 代码清单

接口与类

功能说明

备注说明

com.xxx.commons.retry.RetryService

重试服务工具类

com.xxx.commons.retry.backoff.Backoff

退避算法定义接口

com.xxx.commons.retry.backoff.BackoffExecution

退避算法执行接口

com.xxx.commons.retry.backoff.BackoffType

退避算法类型接口

com.xxx.commons.retry.backoff.BackoffTypeEnum

退避算法类型枚举类

com.xxx.commons.retry.backoff.CustomBackoff

自定义序列退避算法实现

com.xxx.commons.retry.backoff.ExponentialBackoff

指数退避算法实现

com.xxx.commons.retry.backoff.FixedBackoff

固定步长退避算法实现

com.xxx.commons.retry.backoff.GradualBackoff

等差数列退避算法实现

com.xxx.commons.retry.backoff.NoneBackoff

不退避算法实现

com.xxx.commons.retry.backoff.FibonacciBackoff

裴波那契退避算法实现

暂未实现

package com.xxx.commons.retry.backoff;/*** @created 2021-12-31 3:24 PM* @description:*/
public interface BackoffType {/*** 类型编码** @return*/int getCode();/*** 类型名字** @return*/String getName();/*** 类型说明** @return*/String getDesc();
}
package com.xxx.commons.retry.backoff;/*** 重试补偿步长类型** @created 2021-12-20 4:29 PM* @description:*/
public enum BackoffTypeEnum implements BackoffType {/*** 无补偿**/NONE(0, "none", "无补偿"),/*** 固定步长**/FIXED(1, "fixed", "固定步长"),/*** 等差步长*/GRADUAL(2, "gradual", "等差步长"),/*** 指数退避**/EXPONENTIAL(3, "exponential", "指数退避"),/*** 自定义步长*/CUSTOM(4, "custom", "自定义步长"),;private int code;private String name;private String desc;BackoffTypeEnum(int code, String name, String desc) {this.code = code;this.name = name;this.desc = desc;}public static BackoffTypeEnum typeOf(int code) {for (BackoffTypeEnum type : BackoffTypeEnum.values()) {if (type.code == code) {return type;}}return null;}@Overridepublic int getCode() {return code;}@Overridepublic String getName() {return name;}@Overridepublic String getDesc() {return desc;}
}
package com.xxx.commons.retry;/*** @created 2021-12-31 3:21 PM* @description:*/import com.xxx.commons.retry.backoff.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;public class RetryService {static {Runtime.getRuntime().addShutdownHook(RetryServiceShutdownHook.instance());}/*** 重试线程池大小*/public static final int RETRY_CORE_POOL_SIZE = Integer.getInteger(RetryConstants.DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_SIZE_KEY,RetryConstants.DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_DEFAULT_SIZE);/*** 重试服务线程池*/final ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(RETRY_CORE_POOL_SIZE);private static final RetryService instance = new RetryService();public static RetryService getInstance() {return instance;}private RetryService() {RetryServiceShutdownHook.instance().addExecutor(executor);}public ScheduledFuture<?> retry(Callable callable, long delay) {return executor.schedule(callable, delay, BackoffExecution.DEFAULT_TIME_UNIT);}public ScheduledFuture<?> retry(Runnable runnable, long delay) {return executor.schedule(runnable, delay, BackoffExecution.DEFAULT_TIME_UNIT);}public ScheduledFuture<?> retry(Callable callable, long delay, TimeUnit unit) {return executor.schedule(callable, delay, unit);}public ScheduledFuture<?> retry(Runnable runnable, long delay, TimeUnit unit) {return executor.schedule(runnable, delay, unit);}public interface RetryConstants {String DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_SIZE_KEY = "default.retry.service.scheduled.thread.pool.size";int DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_DEFAULT_SIZE = 8;}static class RetryServiceShutdownHook extends Thread {private final Logger logger = LoggerFactory.getLogger(this.getClass());private List<ExecutorService> executors = Collections.synchronizedList(new ArrayList<ExecutorService>());private final static RetryServiceShutdownHook instance = new RetryServiceShutdownHook();public static RetryServiceShutdownHook instance() {return instance;}private RetryServiceShutdownHook() {}public RetryServiceShutdownHook addExecutor(ExecutorService executor) {executors.add(executor);return this;}@Overridepublic void run() {logger.info("retry service shutdown");for (int i = 0; i < executors.size(); i++) {ExecutorService executorService = executors.get(i);try {if (!executorService.isShutdown()) {executorService.shutdown();}} catch (Exception e) {logger.error("retry service shutdown executor service error", e.getMessage());}}}}}


package com.xxx.commons.retry.backoff;import com.xxx.commons.data.constant.CommonConstants;import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;/*** @created 2021-12-27 9:47 AM* @description: 自定义序列退避算法实现*/
public class CustomBackoff implements Backoff, Serializable {private static final long serialVersionUID = 5677908306014056187L;public static final String DEFAULT_SEPARATOR = CommonConstants.SPACE_SEPARATOR;public static final String LEFT_BRACKET = "{";public static final String RIGHT_BRACKET = "}";/*** Constant value indicating an unlimited number of attempt.*/public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;/*** 默认退避时间序列* 示例1:1  2  3  10  10  10  30  60 120 180 600 1800 3600  3600  3600  3600  3600  3600* 示例2:1s 2s 3s 10s 10s 10s 30s 1m 2m  3m  10m 30m  1h    1h    1h    1h    1h    1h* 示例3:1  2  3  10{3}       30  60 120 180 600 1800 3600{6}* 示例4:1s 2s 3s 10s{3}      30s 1m 2m  3m  10m 30m  1h{6}*/public static final String DEFAULT_SEQUENCE = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h{64}";/*** 自定义退避序列*/private String sequence = DEFAULT_SEQUENCE;/*** 最大尝试次数*/private int maxAttempt = UNLIMITED_ATTEMPTS;/*** 自定义序列分隔符*/private String separator = DEFAULT_SEPARATOR;/*** Create an instance with an sequence with DEFAULT.*/public CustomBackoff() {}/*** Create an instance.** @param sequence the origin sequence*/public CustomBackoff(String sequence) {this.sequence = sequence;}public CustomBackoff(String sequence, String separator) {this.sequence = sequence;this.separator = separator;}public CustomBackoff(int maxAttempt) {this.maxAttempt = maxAttempt;}public CustomBackoff(String sequence, int maxAttempt) {this.sequence = sequence;this.maxAttempt = maxAttempt;}/*** @param sequence   the origin sequence* @param maxAttempt the maximum number of attempt* @param separator  the sequence's separator*/public CustomBackoff(String sequence, int maxAttempt, String separator) {this.sequence = sequence;this.maxAttempt = maxAttempt;this.separator = separator;}/*** Set the maximum number of attempt in milliseconds.*/public void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Return the maximum number of attempt in milliseconds.*/public int getMaxAttempt() {return maxAttempt;}public String getSeparator() {return separator;}public void setSeparator(String separator) {this.separator = separator;}@Overridepublic BackoffExecution start() {return new CustomBackoffExecution(this.sequence, this.maxAttempt, this.separator);}public static class CustomBackoffExecution implements BackoffExecution, Serializable {private static final long serialVersionUID = 2991013977130023823L;/*** 自定义退避序列*/private String sequence;/*** 最大尝试次数*/private int maxAttempt;/*** 自定义序列分隔符*/private String separator;/*** 解析后的退避时间间隔列表*/private List<Long> intervals;private long currentElapsedTime = 0;private int currentAttempt = 0;public CustomBackoffExecution() {this(DEFAULT_SEQUENCE, UNLIMITED_ATTEMPTS, DEFAULT_SEPARATOR);}public CustomBackoffExecution(String sequence, int maxAttempt, String separator) {this.sequence = sequence;this.maxAttempt = maxAttempt;this.separator = separator;this.parse();}private void parse() {intervals = new ArrayList<>();HashMap<String, Long> timeUnitTable = new HashMap<String, Long>();timeUnitTable.put("s", 1000L);timeUnitTable.put("m", 1000L * 60);timeUnitTable.put("h", 1000L * 60 * 60);timeUnitTable.put("d", 1000L * 60 * 60 * 24);String[] fields = sequence.split(separator);boolean completed = false;for (String field : fields) {field = field.trim();int count = 1;long multiple = 1;int leftBracket = field.indexOf(CustomBackoff.LEFT_BRACKET);int rightBracket = field.indexOf(CustomBackoff.RIGHT_BRACKET);if (leftBracket > 0 && rightBracket > 0) {count = Integer.parseInt(field.substring(leftBracket + 1, rightBracket));field = field.substring(0, leftBracket);}Long unit = timeUnitTable.get(String.valueOf(field.charAt(field.length() - 1)));if (unit != null) {multiple = unit.longValue();field = field.substring(0, field.length() - 1);}long timeInMills = Long.parseLong(field) * multiple;for (int i = 0; i < count; i++) {if (this.intervals.size() < this.maxAttempt) {this.intervals.add(timeInMills);} else {completed = true;}}if (completed) {break;}}// if maxAttempt greater than intervals's size, then set intervals's size as maxAttemptif (this.intervals.size() < this.maxAttempt) {this.maxAttempt = this.intervals.size();}}@Overridepublic int currentAttempt() {return currentAttempt;}@Overridepublic long getElapsedTime() {return this.currentElapsedTime;}@Overridepublic long nextBackoff() {if (currentAttempt >= maxAttempt) {return STOP;}if (currentAttempt >= this.intervals.size()) {return STOP;}long nextInterval = this.intervals.get(this.currentAttempt);this.currentElapsedTime += nextInterval;this.currentAttempt += 1;return nextInterval;}@Overridepublic void updateCurrentAttempt(int attempt) {if (attempt < 0) {this.currentAttempt = 0;} else if (attempt >= maxAttempt) {this.currentAttempt = maxAttempt;} else {this.currentAttempt = attempt;}this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);}@Overridepublic long getBackoff(int attempt) {if (attempt <= 0) {return 0L;}if (attempt - 1 >= maxAttempt) {return STOP;}if (attempt > this.intervals.size()) {return STOP;}return this.intervals.get(attempt - 1);}@Overridepublic long getElapsedTime(int attempt) {if (attempt >= maxAttempt) {attempt = maxAttempt;}if (attempt >= this.intervals.size()) {attempt = this.intervals.size();}long elapsedTime = 0;for (int i = 0; i < attempt; i++) {elapsedTime += this.intervals.get(i);}return elapsedTime;}public String getSequence() {return sequence;}public void setSequence(String sequence) {this.sequence = sequence;}@Overridepublic int getMaxAttempt() {return maxAttempt;}@Overridepublic void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}public String getSeparator() {return separator;}public void setSeparator(String separator) {this.separator = separator;}public List<Long> getIntervals() {return intervals;}public void setIntervals(List<Long> intervals) {this.intervals = intervals;}public long getCurrentElapsedTime() {return currentElapsedTime;}public void setCurrentElapsedTime(long currentElapsedTime) {this.currentElapsedTime = currentElapsedTime;}public int getCurrentAttempt() {return currentAttempt;}public void setCurrentAttempt(int currentAttempt) {this.currentAttempt = currentAttempt;}@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("CustomBackoff{");sb.append("intervals=").append(intervals);String attemptValue = (maxAttempt == Integer.MAX_VALUE ?"unlimited" : String.valueOf(maxAttempt));sb.append(", maxAttempt=").append(attemptValue);sb.append(", currentElapsedTime=").append(currentElapsedTime);sb.append(", currentAttempt=").append(this.currentAttempt);sb.append('}');return sb.toString();}}public static void main(String[] args) {BackoffExecution backoffExecution = new CustomBackoff().start();System.out.println(backoffExecution.getBackoff(1));System.out.println(backoffExecution.getBackoff(2));System.out.println(backoffExecution.getBackoff(3));System.out.println(backoffExecution.getElapsedTime(1));System.out.println(backoffExecution.getElapsedTime(2));System.out.println(backoffExecution.getElapsedTime(3));}}

​

package com.xxx.commons.retry.backoff;import java.io.Serializable;
import java.util.concurrent.TimeUnit;/*** @created 2021-12-20 4:31 PM* @description:*/
public class ExponentialBackoff implements Backoff, Serializable {private static final long serialVersionUID = -3955367506662250971L;/*** The default initial interval.*/public static final long DEFAULT_INITIAL_INTERVAL = 2000L;/*** The default multiplier (increases the interval by 50%).*/public static final double DEFAULT_MULTIPLIER = 2;/*** The default maximum back off time.*/public static final long DEFAULT_MAX_INTERVAL = 10 * 60 * 1000L;/*** Constant value indicating an unlimited number of attempt.*/public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;private long initialInterval = DEFAULT_INITIAL_INTERVAL;private double multiplier = DEFAULT_MULTIPLIER;private long maxInterval = DEFAULT_MAX_INTERVAL;private int maxAttempt = UNLIMITED_ATTEMPTS;/*** Create an instance with the default settings.** @see #DEFAULT_INITIAL_INTERVAL* @see #DEFAULT_MULTIPLIER* @see #DEFAULT_MAX_INTERVAL*/public ExponentialBackoff() {}/*** Create an instance.** @param maxAttempt the maximum number of attempt*/public ExponentialBackoff(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Create an instance with the supplied settings.** @param initialInterval the initial interval in milliseconds*/public ExponentialBackoff(long initialInterval) {this.initialInterval = initialInterval;this.checkInterval(this.initialInterval, this.maxInterval);}/*** Create an instance with the supplied settings.** @param initialInterval the initial interval* @param timeUnit        the initial interval's time unit* @param multiplier      the multiplier (should be greater than or equal to 1)*/public ExponentialBackoff(long initialInterval, TimeUnit timeUnit, double multiplier) {checkMultiplier(multiplier);this.multiplier = multiplier;this.initialInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);this.checkInterval(this.initialInterval, this.maxInterval);}public ExponentialBackoff(long initialInterval, long maxInterval, TimeUnit timeUnit, double multiplier) {checkMultiplier(multiplier);this.multiplier = multiplier;this.initialInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);this.maxInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(maxInterval, timeUnit);this.checkInterval(this.initialInterval, this.maxInterval);}/*** The initial interval in milliseconds.*/public void setInitialInterval(long initialInterval) {this.initialInterval = initialInterval;this.checkInterval(this.initialInterval, this.maxInterval);}/*** Return the initial interval in milliseconds.*/public long getInitialInterval() {return initialInterval;}/*** The value to multiply the current interval by for each retry attempt.*/public void setMultiplier(double multiplier) {checkMultiplier(multiplier);this.multiplier = multiplier;}/*** Return the value to multiply the current interval by for each retry attempt.*/public double getMultiplier() {return multiplier;}/*** The maximum back off time.*/public void setMaxInterval(long maxInterval) {this.maxInterval = maxInterval;}/*** Return the maximum back off time.*/public long getMaxInterval() {return maxInterval;}/*** Set the maximum number of attempt in milliseconds.*/public void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Return the maximum number of attempt in milliseconds.*/public int getMaxAttempt() {return maxAttempt;}@Overridepublic BackoffExecution start() {return new ExponentialBackoffExecution(initialInterval, maxInterval, multiplier, maxAttempt);}private void checkMultiplier(double multiplier) {if (multiplier < 1) {throw new IllegalArgumentException("Invalid multiplier '" + multiplier + "'. Should be equal" +"or higher than 1. A multiplier of 1 is equivalent to a fixed interval");}}private void checkInterval(long initialInterval, long maxInterval) {if (initialInterval <= 0) {throw new IllegalArgumentException("Invalid initialInterval '" + initialInterval + "'. Should be higher" +" than 0. A initialInterval of 0 is equivalent to no interval");}if (maxInterval <= initialInterval * getMultiplier()) {throw new IllegalArgumentException("Invalid maxInterval '" + maxInterval + "'. Should be higher" +" than initialInterval * multiplier. A maxInterval equal or less than initialInterval * multiplier " +"is equivalent to a fixed interval");}}public static class ExponentialBackoffExecution implements BackoffExecution, Serializable {private static final long serialVersionUID = 672748521748221970L;private long initialInterval;private double multiplier;private long maxInterval;private int maxAttempt;private long currentInterval = -1;private long currentElapsedTime = 0;private int currentAttempt = 0;public ExponentialBackoffExecution() {this(DEFAULT_INITIAL_INTERVAL, DEFAULT_MAX_INTERVAL, DEFAULT_MULTIPLIER, UNLIMITED_ATTEMPTS);}public ExponentialBackoffExecution(long initialInterval, long maxInterval, double multiplier, int maxAttempt) {this.initialInterval = initialInterval;this.maxInterval = maxInterval;this.multiplier = multiplier;this.maxAttempt = maxAttempt;}@Overridepublic int currentAttempt() {return currentAttempt;}@Overridepublic long getElapsedTime() {return this.currentElapsedTime;}@Overridepublic long nextBackoff() {if (currentAttempt >= maxAttempt) {return STOP;}long nextInterval = computeNextInterval();this.currentElapsedTime += nextInterval;this.currentAttempt += 1;return nextInterval;}private long computeNextInterval() {long maxInterval = this.maxInterval;if (this.currentInterval >= maxInterval) {return maxInterval;} else if (this.currentInterval < 0) {this.currentInterval = this.initialInterval;} else {this.currentInterval = multiplyInterval(this.currentInterval, maxInterval);}return this.currentInterval;}private long multiplyInterval(long currentInterval, long maxInterval) {long interval = currentInterval;interval *= this.multiplier;return (interval > maxInterval ? maxInterval : interval);}@Overridepublic void updateCurrentAttempt(int attempt) {if (attempt < 0) {this.currentAttempt = 0;} else if (attempt >= maxAttempt) {this.currentAttempt = maxAttempt;} else {this.currentAttempt = attempt;}this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);}@Overridepublic long getBackoff(int attempt) {if (attempt <= 0) {return 0L;}if (attempt - 1 >= maxAttempt) {return STOP;}long interval = this.initialInterval;long maxInterval = this.maxInterval;for (long i = 1; i < attempt; i++) {interval = multiplyInterval(interval, maxInterval);if (interval >= maxInterval) {break;}}return interval;}@Overridepublic long getElapsedTime(int attempt) {if (attempt >= maxAttempt) {attempt = maxAttempt;}long interval = this.initialInterval;long maxInterval = this.maxInterval;long elapsedTime = 0;if (attempt <= 0) {return elapsedTime;} else {elapsedTime = interval;}for (long i = 1; i < attempt; i++) {if (interval < maxInterval) {interval = multiplyInterval(interval, maxInterval);}elapsedTime += interval;}return elapsedTime;}public long getInitialInterval() {return initialInterval;}public void setInitialInterval(long initialInterval) {this.initialInterval = initialInterval;}public double getMultiplier() {return multiplier;}public void setMultiplier(double multiplier) {this.multiplier = multiplier;}public long getMaxInterval() {return maxInterval;}public void setMaxInterval(long maxInterval) {this.maxInterval = maxInterval;}@Overridepublic int getMaxAttempt() {return maxAttempt;}@Overridepublic void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}public long getCurrentInterval() {return currentInterval;}public void setCurrentInterval(long currentInterval) {this.currentInterval = currentInterval;}public long getCurrentElapsedTime() {return currentElapsedTime;}public void setCurrentElapsedTime(long currentElapsedTime) {this.currentElapsedTime = currentElapsedTime;}public int getCurrentAttempt() {return currentAttempt;}public void setCurrentAttempt(int currentAttempt) {this.currentAttempt = currentAttempt;}@Overridepublic String toString() {StringBuilder sb = new StringBuilder("ExponentialBackOff{");sb.append("currentInterval=").append(this.currentInterval < 0 ? "n/a" : this.currentInterval + "ms");sb.append(", multiplier=").append(this.multiplier);sb.append('}');return sb.toString();}}}

package com.xxx.commons.retry.backoff;import java.io.Serializable;
import java.util.concurrent.TimeUnit;/*** @created 2021-12-20 4:32 PM* @description:*/
public class FixedBackoff implements Backoff, Serializable {private static final long serialVersionUID = 2511140811757045231L;/*** The default recovery interval: 5000 ms = 5 seconds.*/public static final long DEFAULT_INTERVAL = 5000L;/*** Constant value indicating an unlimited number of attempt.*/public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;private long interval = DEFAULT_INTERVAL;private int maxAttempt = UNLIMITED_ATTEMPTS;/*** Create an instance with an interval of {@value #DEFAULT_INTERVAL}* ms and an unlimited number of attempt.*/public FixedBackoff() {}/*** Create an instance.** @param maxAttempt the maximum number of attempt*/public FixedBackoff(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Create an instance.** @param interval the interval between two attempt* @param timeUnit the time unit of interval*/public FixedBackoff(long interval, TimeUnit timeUnit) {this.interval = BackoffExecution.DEFAULT_TIME_UNIT.convert(interval, timeUnit);this.maxAttempt = maxAttempt;}/*** Create an instance.** @param maxAttempt the maximum number of attempt* @param interval   the interval between two attempt*/public FixedBackoff(int maxAttempt, long interval) {this.interval = interval;this.maxAttempt = maxAttempt;}/*** Create an instance.** @param maxAttempt the maximum number of attempt* @param interval   the interval between two attempt* @param timeUnit   the time unit of interval*/public FixedBackoff(int maxAttempt, long interval, TimeUnit timeUnit) {this.interval = BackoffExecution.DEFAULT_TIME_UNIT.convert(interval, timeUnit);this.maxAttempt = maxAttempt;}/*** Set the interval between two attempt in milliseconds.*/public void setInterval(long interval) {this.interval = interval;}/*** Return the interval between two attempt in milliseconds.*/public long getInterval() {return interval;}/*** Set the maximum number of attempt in milliseconds.*/public void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Return the maximum number of attempt in milliseconds.*/public int getMaxAttempt() {return maxAttempt;}@Overridepublic BackoffExecution start() {return new FixedBackoffExecution(interval, maxAttempt);}public static class FixedBackoffExecution implements BackoffExecution, Serializable {private static final long serialVersionUID = 1656175761226107038L;private long interval;private int maxAttempt;private int currentAttempt = 0;private long currentElapsedTime = 0;public FixedBackoffExecution() {this(DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);}public FixedBackoffExecution(long interval, int maxAttempt) {this.interval = interval;this.maxAttempt = maxAttempt;}public long getInterval() {return interval;}public void setInterval(long interval) {this.interval = interval;}@Overridepublic int getMaxAttempt() {return maxAttempt;}@Overridepublic void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}public int getCurrentAttempt() {return currentAttempt;}public void setCurrentAttempt(int currentAttempt) {this.currentAttempt = currentAttempt;}public long getCurrentElapsedTime() {return currentElapsedTime;}public void setCurrentElapsedTime(long currentElapsedTime) {this.currentElapsedTime = currentElapsedTime;}@Overridepublic int currentAttempt() {return currentAttempt;}@Overridepublic long getElapsedTime() {return this.currentElapsedTime;}@Overridepublic long nextBackoff() {if (this.currentAttempt < this.maxAttempt) {long nextInterval = this.interval;this.currentElapsedTime += nextInterval;this.currentAttempt++;return nextInterval;} else {return STOP;}}@Overridepublic void updateCurrentAttempt(int attempt) {if (attempt < 0) {this.currentAttempt = 0;} else if (attempt >= maxAttempt) {this.currentAttempt = maxAttempt;} else {this.currentAttempt = attempt;}this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);}@Overridepublic long getBackoff(int attempt) {if (attempt <= 0) {return 0L;}if (attempt - 1 >= maxAttempt) {return STOP;}return this.interval;}@Overridepublic long getElapsedTime(int attempt) {return this.interval * attempt;}@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("FixedBackoff{");sb.append("interval=").append(this.interval);String attemptValue = (this.maxAttempt == Integer.MAX_VALUE ?"unlimited" : String.valueOf(this.maxAttempt));sb.append(", maxAttempt=").append(attemptValue);sb.append(", currentAttempt=").append(this.currentAttempt);sb.append('}');return sb.toString();}}}
package com.xxx.commons.retry.backoff;import java.io.Serializable;
import java.util.concurrent.TimeUnit;import static com.xxx.commons.retry.backoff.BackoffExecution.DEFAULT_TIME_UNIT;/*** @created 2021-12-20 4:33 PM* @description:*/
public class GradualBackoff implements Backoff, Serializable {private static final long serialVersionUID = -4082336395861849848L;/*** The default initial interval.*/public static final long DEFAULT_INITIAL_INTERVAL = 2000L;/*** The default recovery interval: 3000 ms = 3 seconds.*/public static final long DEFAULT_INTERVAL = 3000L;/*** Constant value indicating an unlimited number of attempt.*/public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;private long initialInterval = DEFAULT_INITIAL_INTERVAL;private long interval = DEFAULT_INTERVAL;private int maxAttempt = UNLIMITED_ATTEMPTS;/*** Create an instance with an interval of {@value #DEFAULT_INTERVAL}* ms and an unlimited number of attempt.*/public GradualBackoff() {}/*** Create an instance.** @param maxAttempt the maximum number of attempt*/public GradualBackoff(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Create an instance.** @param interval the interval between two attempt* @param timeUnit the time unit of interval*/public GradualBackoff(long initialInterval, long interval, TimeUnit timeUnit) {this.initialInterval = DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);this.interval = DEFAULT_TIME_UNIT.convert(interval, timeUnit);this.maxAttempt = maxAttempt;}/*** Create an instance.** @param maxAttempt the maximum number of attempt* @param interval   the interval between two attempt*/public GradualBackoff(int maxAttempt, long initialInterval, long interval) {this.initialInterval = initialInterval;this.interval = interval;this.maxAttempt = maxAttempt;}/*** Create an instance.** @param maxAttempt the maximum number of attempt* @param interval   the interval between two attempt* @param timeUnit   the time unit of interval*/public GradualBackoff(int maxAttempt, long initialInterval, long interval, TimeUnit timeUnit) {this.initialInterval = DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);this.interval = DEFAULT_TIME_UNIT.convert(interval, timeUnit);this.maxAttempt = maxAttempt;}/*** Return the interval of first attempt in milliseconds.** @return*/public long getInitialInterval() {return initialInterval;}/*** Set the interval of first attempt in milliseconds.*/public void setInitialInterval(long initialInterval) {this.initialInterval = initialInterval;}/*** Set the interval between two attempt in milliseconds.*/public void setInterval(long interval) {this.interval = interval;}/*** Return the interval between two attempt in milliseconds.*/public long getInterval() {return interval;}/*** Set the maximum number of attempt in milliseconds.*/public void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Return the maximum number of attempt in milliseconds.*/public int getMaxAttempt() {return maxAttempt;}@Overridepublic BackoffExecution start() {return new GradualBackoffExecution(initialInterval, interval, maxAttempt);}public static class GradualBackoffExecution implements BackoffExecution, Serializable {private static final long serialVersionUID = 6691539566098442985L;private long initialInterval;private long interval;private int maxAttempt;private int currentAttempt = 0;private long currentElapsedTime = 0;public GradualBackoffExecution() {this(DEFAULT_INITIAL_INTERVAL, DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);}public GradualBackoffExecution(long initialInterval, long interval, int maxAttempt) {this.initialInterval = initialInterval;this.interval = interval;this.maxAttempt = maxAttempt;}@Overridepublic int currentAttempt() {return currentAttempt;}@Overridepublic long getElapsedTime() {return this.currentElapsedTime;}@Overridepublic long nextBackoff() {if (this.currentAttempt < this.maxAttempt) {long nextInterval = this.currentAttempt == 0 ? this.initialInterval : this.interval;this.currentElapsedTime += nextInterval;this.currentAttempt++;return nextInterval;} else {return STOP;}}@Overridepublic void updateCurrentAttempt(int attempt) {if (attempt < 0) {this.currentAttempt = 0;} else if (attempt >= maxAttempt) {this.currentAttempt = maxAttempt;} else {this.currentAttempt = attempt;}this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);}@Overridepublic long getBackoff(int attempt) {if (attempt <= 0) {return 0L;}if (attempt - 1 >= maxAttempt) {return STOP;}return attempt == 1 ? this.initialInterval : this.interval;}@Overridepublic long getElapsedTime(int attempt) {return attempt == 1 ? this.initialInterval : this.initialInterval + this.interval * (attempt - 1);}public long getInitialInterval() {return initialInterval;}public void setInitialInterval(long initialInterval) {this.initialInterval = initialInterval;}public long getInterval() {return interval;}public void setInterval(long interval) {this.interval = interval;}@Overridepublic int getMaxAttempt() {return maxAttempt;}@Overridepublic void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}public int getCurrentAttempt() {return currentAttempt;}public void setCurrentAttempt(int currentAttempt) {this.currentAttempt = currentAttempt;}public long getCurrentElapsedTime() {return currentElapsedTime;}public void setCurrentElapsedTime(long currentElapsedTime) {this.currentElapsedTime = currentElapsedTime;}@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("GradualBackoff{");sb.append("initialInterval=").append(this.initialInterval);sb.append("interval=").append(this.interval);String attemptValue = (this.maxAttempt == Integer.MAX_VALUE ?"unlimited" : String.valueOf(this.maxAttempt));sb.append(", maxAttempt=").append(attemptValue);sb.append(", currentAttempt=").append(this.currentAttempt);sb.append('}');return sb.toString();}}}
package com.xxx.commons.retry.backoff;import java.io.Serializable;/*** @created 2021-12-20 4:34 PM* @description:*/
public class NoneBackoff implements Backoff, Serializable {private static final long serialVersionUID = 8227959838869099892L;/*** The default recovery interval: 0 ms = 0 seconds.*/public static final long DEFAULT_INTERVAL = 0L;/*** Constant value indicating an unlimited number of attempt.*/public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;private long interval = DEFAULT_INTERVAL;private int maxAttempt = UNLIMITED_ATTEMPTS;/*** Create an instance with an interval of {@value #DEFAULT_INTERVAL}* ms and an unlimited number of attempt.*/public NoneBackoff() {}/*** Create an instance.** @param maxAttempt the maximum number of attempt*/public NoneBackoff(int maxAttempt) {this.maxAttempt = maxAttempt;}/*** Return the interval between two attempt in milliseconds.*/public long getInterval() {return interval;}/*** Return the maximum number of attempt in milliseconds.*/public int getMaxAttempt() {return maxAttempt;}/*** Set the maximum number of attempt in milliseconds.*/public void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}@Overridepublic BackoffExecution start() {return new NoneBackoffExecution(interval, maxAttempt);}public static class NoneBackoffExecution implements BackoffExecution, Serializable {private static final long serialVersionUID = 2453613900451888865L;private long interval;private int maxAttempt;private int currentAttempt = 0;private long currentElapsedTime = 0;public NoneBackoffExecution() {this(DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);}public NoneBackoffExecution(long interval, int maxAttempt) {this.interval = interval;this.maxAttempt = maxAttempt;}@Overridepublic int currentAttempt() {return currentAttempt;}@Overridepublic long getElapsedTime() {return this.currentElapsedTime;}@Overridepublic long nextBackoff() {if (this.currentAttempt < this.maxAttempt) {long nextInterval = this.interval;this.currentElapsedTime += nextInterval;this.currentAttempt++;return nextInterval;} else {return STOP;}}@Overridepublic void updateCurrentAttempt(int attempt) {if (attempt < 0) {this.currentAttempt = 0;} else if (attempt >= maxAttempt) {this.currentAttempt = maxAttempt;} else {this.currentAttempt = attempt;}this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);}@Overridepublic long getBackoff(int attempt) {if (attempt <= 0) {return 0L;}if (attempt - 1 >= maxAttempt) {return STOP;}return this.interval;}@Overridepublic long getElapsedTime(int attempt) {return this.interval * attempt;}public long getInterval() {return interval;}public void setInterval(long interval) {this.interval = interval;}@Overridepublic int getMaxAttempt() {return maxAttempt;}@Overridepublic void setMaxAttempt(int maxAttempt) {this.maxAttempt = maxAttempt;}public int getCurrentAttempt() {return currentAttempt;}public void setCurrentAttempt(int currentAttempt) {this.currentAttempt = currentAttempt;}public long getCurrentElapsedTime() {return currentElapsedTime;}public void setCurrentElapsedTime(long currentElapsedTime) {this.currentElapsedTime = currentElapsedTime;}@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("NoneBackoff{");sb.append("interval=").append(this.interval);sb.append(", maxAttempt=").append(this.maxAttempt);sb.append('}');return sb.toString();}}
}

2.2.3 业务使用示例

网关使用示例:

  • 添加依赖

    <!-- 公共模块 --><dependency><groupId>com.xxx.arch</groupId><artifactId>xxx-commons-recipes</artifactId><version>1.0.8</version> <!-- <version>${xxx.commons.version}</version> --></dependency>

  • 初始化

@Configuration
@AutoConfigureAfter(OnsConfig.class)
public class LinkBean {public static final String MESSAGE_DELAY_LEVEL = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";@Beanpublic BackoffExecution backoffExecution() {return new CustomBackoff(MESSAGE_DELAY_LEVEL, MAX_RETRY_COUNT).start();}...
}

  • 具体使用

@Slf4j
public class RetryFilterFactory implements FilterFactory {private Producer producer;private BackoffExecution backoffExecution;public RetryFilterFactory(Producer producer, BackoffExecution backoffExecution) {this.producer = producer;this.backoffExecution = backoffExecution;}@Overridepublic String name() {return "retry";}@Overridepublic Filter apply(Properties properties) {return (context, chain) -> {int retry = context.getRetryCount();retry++;long retryTime = context.getAttributeOrDefault(LinkContext.FAILOVER_RETRY_TIME_ATTRIBUTE, 0L);context.getAttributes().put(LinkContext.FAILOVER_RETRY_TIME_ATTRIBUTE,retryTime + backoffExecution.getBackoff(retry));try {producer.send(context);} catch (Exception exp) {log.error("master send context: {}, error:", context, exp);throw new LinkIOException("send master mq error");}chain.filter(context);};}
}

四、未来展望

希望大家一起来共建xxx-commons组件，也希望xxx-commons组件能够成为内部基础组件被广泛使用，提升系统和业务开发效率，并提升开发质量。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/111361.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

人防行业通信系统

人防行业通信系统

深圳市华脉智联科技有限公司是一家拥有核心自主知识产权的高科技企业&#xff0c;公司致力于公网对讲、融合通信、应急通信、执法调度等领域的系统和技术的开发和探讨&#xff0c;为行业用户提供一整套以通信为基础&#xff0c;软硬件结合的实战解决方案。华脉智联始终坚持将解…
阅读更多...
RabbitMQ中的核心概念和交换机类型

RabbitMQ中的核心概念和交换机类型

目录 一、RabbitMQ相关概念二、Exchange类型三、RabbitMQ概念模型总结 一、RabbitMQ相关概念 Producer&#xff1a;生产者&#xff0c;就是投递消息的一方。生产者创建消息&#xff0c;然后发布到RabbitMQ中。消息一般可以包含两个部分&#xff1a;消息体和附加消息。 消息体…
阅读更多...
git 新建 branch 推送 到服务器

git 新建 branch 推送 到服务器

通常情况下&#xff0c;需要开发一个模块&#xff0c;从 master 新建立了一个 分支&#xff0c;newbranch&#xff0c;如果推送到服务器&#xff1b; 1&#xff1a;从远程 master 建立本地分支 newbranch&#xff1b; git checkout -b newbranch origin/master 2:当修改完成代码…
阅读更多...
@JsonCreator(mode = JsonCreator.Mode.DELEGATING) @JsonValue解释

@JsonCreator(mode = JsonCreator.Mode.DELEGATING) @JsonValue解释

@JsonCreator(mode = JsonCreator.Mode.DELEGATING)public MessageId(Long id) {this.id = id;}<
阅读更多...
jmeter集成kafka测试

jmeter集成kafka测试

Kafka的使用 查看kafka的topic ./kafka-topics --bootstrap-server 10.1.9.84:9092 --list 查看topic信息 ./kafka-topics --bootstrap-server 10.1.9.84:9092 --describe --topic topic_example_1 创建topic 创建topic名为test&#xff0c;分区数为8&#xff0c;副本数为…
阅读更多...
nginx动静分离

nginx动静分离

1、简单概述 Nginx动静分离简单说就是将动态请求和静态请求分开。可以理解说是用nginx处理静态页面&#xff0c;Tomcat处理动态页面。动静分离目前分为两种 方式一&#xff1a;纯粹将静态文件独立成单独的域名&#xff0c;放在独立的服务器上&#xff0c;也是目前主流的推崇方…
阅读更多...
CSS【基础】

CSS【基础】

目录 一、CSS的介绍 二、CSS语法规则 三、CSS引入方式 四、CSS的基础选择器 五、CSS属性: 字体font 六、CSS属性&#xff1a;文本text 七、CSS属性&#xff1a;颜色 八、样式层叠问题 九、谷歌浏览器的调试工具 十、拓展&#xff1a;标签(盒子)水平居中的方法 一、C…
阅读更多...
idgen导入Android11源码

idgen导入Android11源码

文章目录 配置下载AS编译源码依赖导入玩一下andorid.iml 注意&#xff1a; 有些时候发现为啥自己编译就这么难呢&#xff1f;不是卡死就无数次重启虚拟机&#xff0c;一切的原罪在配置过低&#xff0c;换句话说就是穷。关于导入源码的下载参考 Android Studio for Platform (AS…
阅读更多...
MAC如何在根目录创建文件

MAC如何在根目录创建文件

在这之前先明确一下啥是根目录。 打开终端&#xff0c;输入cd /&#xff0c;然后输入 ls 查看根目录下有哪些文件 可以看到 usr、etc、opt 这些文件的地方才叫根目录&#xff0c;而不是以用户命名&#xff0c;可以看到音乐、应用程序、影片、桌面的地方哈 介绍一种叫做软连接…
阅读更多...
python字典

python字典

字典 字典定义创建字典 字典定义 字典是python语言中唯一的映射类型。这种映射类型由键&#xff08;key&#xff09;和值&#xff08;value&#xff09;组成&#xff0c;是“键值对”的无序可变序列 定义字典时&#xff0c;每个元组的键和值用冒号隔开&#xff0c;相邻元素用…
阅读更多...
lspci源码

lspci源码

lspci 显示Linux系统的pci设备最简单的方法就是使用lspci命令&#xff0c;前提是要安装pciutils包&#xff08;centos在最小化安装时不会自带该包&#xff0c;需要自己下载安装&#xff09; pciutils包的源码github地址为&#xff1a; https://github.com/pciutils/pciutils …
阅读更多...
Python数据挖掘实用案例——自动售货机销售数据分析与应用

Python数据挖掘实用案例——自动售货机销售数据分析与应用

&#x1f680;欢迎来到本文&#x1f680; &#x1f349;个人简介&#xff1a;陈童学哦&#xff0c;目前学习C/C、算法、Python、Java等方向&#xff0c;一个正在慢慢前行的普通人。 &#x1f3c0;系列专栏&#xff1a;陈童学的日记 &#x1f4a1;其他专栏&#xff1a;CSTL&…
阅读更多...
【试题028】C语言关于逻辑与的短路例题

【试题028】C语言关于逻辑与的短路例题

1.题目&#xff1a;设inta1,b;&#xff0c;执行b0&&(a);后&#xff0c;变量a的值是&#xff1f; 2.代码解析&#xff1a; #include <stdio.h> int main() {//设inta1,b;执行b0&&(a);后&#xff0c;变量a的值是?int a 1, b;printf("表达式的值是…
阅读更多...
SQL 语法

SQL 语法

SQL 语法规则 SQL语句总是以关键字开始&#xff0c;如SELECT、INSERT、UPDATE、DELETE、DROP、CREATE。SQL语句以分号结尾。SQL不区分大小写&#xff0c;意味着update与UPDATE相同。 数据库表 数据库通常包含一个或多个表。每个表都用一个名称标识&#xff08;例如&#xff0c;…
阅读更多...
【ELK使用指南 2】常用的 Logstash filter 插件详解(附应用实例）

【ELK使用指南 2】常用的 Logstash filter 插件详解(附应用实例）

Logstash filter 一、logstash filter过滤插件的常用模块简介二、grok 正则捕获插件2.1 grok插件的作用2.2 内置正则表达式2.3 自定义正则表达式 三、mutate 数据修改插件3.1 mutate插件的作用3.2 常用的配置选项3.3 mutate插件应用实例 四、multiline 多行合并插件4.1 multili…
阅读更多...
Mac上安装和配置Git

Mac上安装和配置Git

在Mac上安装和配置Git是一个相对简单的过程&#xff0c;以下是一份详细的步骤指南。 首先&#xff0c;你需要确保你的Mac已经安装了Homebrew&#xff08;如果还没有安装&#xff0c;可以通过以下命令安装&#xff1a;&#xff09;&#xff0c;Homebrew是一个包管理器&#xff…
阅读更多...
Unity之ShaderGraph如何实现马赛克效果

Unity之ShaderGraph如何实现马赛克效果

前言 今天我们来实现一个马赛克的效果 如下所示&#xff1a; 关键节点 Posterize&#xff1a;色调分离节点 图像的色调分离或色调分离需要将色调的连续渐变转换为色调较少的几个区域&#xff0c;并从一种色调突然改变为另一种色调。 原理 原理就是通过色调分离节点&…
阅读更多...
thinkphp队列的使用？

thinkphp队列的使用？

1.安装队列依赖 由于框架版本原因可以选择适合的版本 composer require topthink/think-queue 由于我是tp框架5.1的&#xff0c;所以选择了think-queue 1.1.6 composer require topthink/think-queue 1.1.6 判断安装成功 php think queue:work -h image.png 2.配置文件…
阅读更多...
yolov5多个框重叠问题

yolov5多个框重叠问题

NMS&#xff08;Non-Maximum Suppression&#xff0c;非极大值抑制&#xff09;是一种在计算机视觉和目标检测领域常用的技术。它通常用于在图像或视频中找出物体或目标的位置&#xff0c;并剔除重叠的边界框&#xff0c;以确保最终的检测结果准确且不重叠。 会出现多个框重叠…
阅读更多...
阿里云-AnalyticDB【分析型数据库】总结介绍

阿里云-AnalyticDB【分析型数据库】总结介绍

一、背景 随着企业IT和互联网系统的发展&#xff0c;产生了越来越多的数据。数据量的积累带来了质的飞跃&#xff0c;使得数据应用从业务系统的一部分演变得愈发独立。物流、交通、新零售等越来越多的行业需要通过OLAP做到精细化运营&#xff0c;从而调控生产规则、运营效率、企…
阅读更多...
最新文章

Copyright @ 2022~2023