针对Spring的Spring Retry 我发现了这样一个大家都不知道的技巧！

外部服务对于调用者来说一般都是不可靠的，尤其是在网络环境比较差的情况下，网络抖动很容易导致请求超时等异常情况，这时候就需要使用失败重试策略重新调用 API 接口来获取。重试策略在服务治理方面也有很广泛的使用，通过定时检测，来查看服务是否存活。

Spring异常重试框架Spring Retry

Spring Retry支持集成到Spring或者Spring Boot项目中，而它支持AOP的切面注入写法，所以在引入时必须引入aspectjweaver.jar包。

1.引入maven依赖

 <dependency><groupId>org.springframework.retry</groupId><artifactId>spring-retry</artifactId><version>1.1.2.RELEASE</version>
</dependency>
<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.6</version>
</dependency>

2.添加@Retryable和@Recover注解

@Retryable注解，被注解的方法发生异常时会重试

  • value：指定发生的异常进行重试
  • include：和value一样，默认空，当exclude也为空时，所有异常都重试
  • exclude：指定异常不重试，默认空，当include也为空时，所有异常都重试
  • maxAttemps：重试次数，默认3
  • backoff：重试补偿机制，默认没有

@Backoff注解

  • delay:指定延迟后重试
    multiplier:指定延迟的倍数，比如delay=5000l,multiplier=2时，第一次重试为5秒后，第二次为10秒，第三次为20秒

@Recover注解：
当重试到达指定次数时，被注解的方法将被回调，可以在该方法中进行日志处理。需要注意的是发生的异常和入参类型一致时才会回调。

@Service
public class RemoteService {@Retryable(value = {Exception.class}, maxAttempts = 5, backoff = @Backoff(delay = 5000L, multiplier = 1))
public void call() {System.out.println(LocalDateTime.now() + ": do something...");throw new RuntimeException(LocalDateTime.now() + ": 运行调用异常");
}@Recover
public void recover(Exception e) {System.out.println(e.getMessage());
}

3.启用重试功能

启动类上面添加@EnableRetry注解，启用重试功能，或者在使用retry的service上面添加也可以，或者Configuration配置类上面。
建议所有的Enable配置加在启动类上，可以清晰的统一管理使用的功能。

@SpringBootApplication
@EnableRetry
public class App {public static void main(String[] args) throws Exception {ConfigurableApplicationContext context = SpringApplication.run(App.class, args);System.out.println("Start app success.");RemoteService bean = context.getBean(RemoteService.class);bean.call();}
}

4.启动服务，运行测试

通过在启动类Context调用服务看到如下打印:
2019-03-09T15:22:12.781: do something...
2019-03-09T15:22:17.808: do something...
2019-03-09T15:22:22.835: do something...
2019-03-09T15:22:27.861: do something...
2019-03-09T15:22:32.887: do something...
2019-03-09T15:22:32.887: 运行调用异常

基于guava的重试组件Guava-Retryer
直接看组件作者对此组件的介绍：
This is a small extension to Google’s Guava library to allow for the creation of configurable retrying strategies for an arbitrary function call, such as something that talks to a remote service with flaky uptime.（这是对Google的guava库的一个小扩展，允许为任意函数调用创建可配置的重试策略，例如与运行时间不稳定的远程服务对话的策略。）
第一步引入maven坐标：

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

1.其主要接口及策略介绍

  • Attempt：一次执行任务；
  • AttemptTimeLimiter：单次任务执行时间限制（如果单次任务执行超时，则终止执行当前任务）；
  • BlockStrategies：任务阻塞策略（通俗的讲就是当前任务执行完，下次任务还没开始这段时间做什么……- - BlockStrategies.THREAD_SLEEP_STRATEGY 也就是调用 Thread.sleep(sleepTime);
  • RetryException：重试异常；
  • RetryListener：自定义重试监听器，可以用于异步记录错误日志；
  • StopStrategy：停止重试策略，提供三种：
  • StopAfterDelayStrategy：设定一个最长允许的执行时间；比如设定最长执行10s，无论任务执行次数，只要重试的时候超出了最长时间，则任务终止，并返回重试异常RetryException；
  • NeverStopStrategy：不停止，用于需要一直轮训直到返回期望结果的情况；
  • StopAfterAttemptStrategy：设定最大重试次数，如果超出最大重试次数则停止重试，并返回重试异常；
  • WaitStrategy：等待时长策略（控制时间间隔），返回结果为下次执行时长：
  • FixedWaitStrategy：固定等待时长策略；
  • RandomWaitStrategy：随机等待时长策略（可以提供一个最小和最大时长，等待时长为其区间随机值）
  • IncrementingWaitStrategy：递增等待时长策略（提供一个初始值和步长，等待时间随重试次数增加而增加）
  • ExponentialWaitStrategy：指数等待时长策略；
  • FibonacciWaitStrategy ：Fibonacci 等待时长策略；
  • ExceptionWaitStrategy ：异常时长等待策略；
  • CompositeWaitStrategy ：复合时长等待策略；

2.根据结果判断是否重试

使用场景：如果返回值决定是否要重试。
重试接口：

private static Callable<String> callableWithResult() {return new Callable<String>() {int counter = 0;public String call() throws Exception {counter++;System.out.println(LocalDateTime.now() + ": do something... " + counter);if (counter < 5) {return "james";}return "kobe";}};
}

测试：

public static void main(String[] args) {Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfResult(result -> !result.contains("kobe")).build();retry.call(callableWithResult());
}

输出：

2019-03-09T15:40:23.706: do something... 1
2019-03-09T15:40:23.710: do something... 2
2019-03-09T15:40:23.711: do something... 3
2019-03-09T15:40:23.711: do something... 4
2019-03-09T15:40:23.711: do something... 5

3.根据异常判断是否重试

使用场景：根据抛出异常类型判断是否执行重试。
重试接口：

private static Callable<String> callableWithResult() {return new Callable<String>() {int counter = 0;public String call() throws Exception {counter++;System.out.println(LocalDateTime.now() + ": do something... " + counter);if (counter < 5) {throw new RuntimeException("Run exception");}//加入Java开发交流君样：756584822一起吹水聊天return "kobe";}};
}

测试：

public static void main(String[] args) throws ExecutionException, RetryException{Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.neverStop()).build();retry.call(callableWithResult());
}

输出：

2019-03-09T15:53:27.682: do something... 1
2019-03-09T15:53:27.686: do something... 2
2019-03-09T15:53:27.686: do something... 3
2019-03-09T15:53:27.687: do something... 4
2019-03-09T15:53:27.687: do something... 5

4.重试策略——设定无限重试

使用场景：在有异常情况下，无限重试（默认执行策略），直到返回正常有效结果；

 Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.neverStop()).build();retry.call(callableWithResult());

5.重试策略——设定最大的重试次数

使用场景：在有异常情况下，最多重试次数，如果超过次数则会抛出异常；

private static Callable<String> callableWithResult() {return new Callable<String>() {int counter = 0;public String call() throws Exception {counter++;System.out.println(LocalDateTime.now() + ": do something... " + counter);throw new RuntimeException("Run exception");}};
}

测试:

public static void main(String[] args) throws ExecutionException, RetryException{Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(4)).build();retry.call(callableWithResult());
}

输出：

2019-03-09T16:02:29.471: do something... 1
2019-03-09T16:02:29.477: do something... 2
2019-03-09T16:02:29.478: do something... 3
2019-03-09T16:02:29.478: do something... 4
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 4 attempts.

6.等待策略——设定重试等待固定时长策略
使用场景：设定每次重试等待间隔固定为10s；

 public static void main(String[] args) throws ExecutionException, RetryExceptio{Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(4)).withWaitStrategy(WaitStrategies.fixedWait(10, TimeUnit.SECONDS)).build();retry.call(callableWithResult());
}

测试输出，可以看出调用间隔是10S：

2019-03-09T16:06:34.457: do something... 1
2019-03-09T16:06:44.660: do something... 2
2019-03-09T16:06:54.923: do something... 3
2019-03-09T16:07:05.187: do something... 4
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 4 attempts.

7.等待策略——设定重试等待时长固定增长策略

场景：设定初始等待时长值，并设定固定增长步长，但不设定最大等待时长；

public static void main(String[] args) throws ExecutionException, RetryException {Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(4)).withWaitStrategy(WaitStrategies.incrementingWait(1, SECONDS, 1, SECONDS)).build();
//加入Java开发交流君样：756584822一起吹水聊天retry.call(callableWithResult());
}

测试输出，可以看出调用间隔时间递增1秒：

2019-03-09T18:46:30.256: do something... 1
2019-03-09T18:46:31.260: do something... 2
2019-03-09T18:46:33.260: do something... 3
2019-03-09T18:46:36.260: do something... 4
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 4 attempts.

8.等待策略——设定重试等待时长按指数增长策略

使用场景：根据multiplier值按照指数级增长等待时长，并设定最大等待时长；

 public static void main(String[] args) throws ExecutionException, RetryExceptio{Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(4)).withWaitStrategy(WaitStrategies.exponentialWait(1000, 10,SECONDS)).build();retry.call(callableWithResult());
}

这个重试策略和入参不是很懂，好吧，查看源码：\

@Immutable
private static final class ExponentialWaitStrategy implements WaitStrategy {private final long multiplier;private final long maximumWait;public ExponentialWaitStrategy(long multiplier, long maximumWait) {Preconditions.checkArgument(multiplier > 0L, "multiplier must be > 0 but is %d", new Object[]{Long.valueOf(multiplier)});Preconditions.checkArgument(maximumWait >= 0L, "maximumWait must be >= 0 but is %d", new Object[]{Long.valueOf(maximumWait)});Preconditions.checkArgument(multiplier < maximumWait, "multiplier must be < maximumWait but is %d", new Object[]{Long.valueOf(multiplier)});this.multiplier = multiplier;this.maximumWait = maximumWait;}
//加入Java开发交流君样：756584822一起吹水聊天public long computeSleepTime(Attempt failedAttempt) {double exp = Math.pow(2.0D, (double)failedAttempt.getAttemptNumber());long result = Math.round((double)this.multiplier * exp);if(result > this.maximumWait) {result = this.maximumWait;}return result >= 0L?result:0L;}
}

通过源码看出ExponentialWaitStrategy是一个不可变的内部类，构造器中校验入参，最重要的延迟时间计算方法computeSleepTime()，可以看出延迟时间计算方式

计算以2为底失败次数为指数的值
第一步的值构造器第一个入参相乘，然后四舍五入得到延迟时间（毫秒）

通过以上分析可知入参为1000时间隔是应该为2，4，8s
测试输出，可以看出调用间隔时间 2×1000，4×1000，8×1000：

2019-03-09T19:11:23.905: do something... 1
2019-03-09T19:11:25.908: do something... 2
2019-03-09T19:11:29.908: do something... 3
2019-03-09T19:11:37.909: do something... 4
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 4 attempts.

9.等待策略——设定重试等待时长按斐波那契数列策略

使用场景：根据multiplier值按照斐波那契数列增长等待时长，并设定最大等待时长，斐波那契数列：1、1、2、3、5、8、13、21、34、……

public static void main(String[] args) throws ExecutionException, RetryException {Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(4)).withWaitStrategy(WaitStrategies.fibonacciWait(1000, 10, SECONDS)).build();
//加入Java开发交流君样：756584822一起吹水聊天retry.call(callableWithResult());
}

同样，看源码可知计算可知延迟时间为斐波那契数列和第一入参的乘积（毫秒）

public long computeSleepTime(Attempt failedAttempt) {long fib = this.fib(failedAttempt.getAttemptNumber());long result = this.multiplier * fib;if(result > this.maximumWait || result < 0L) {result = this.maximumWait;}return result >= 0L?result:0L;
}

测试输出，可看出间隔调用为1×1000，1×1000，2×1000：

2019-03-09T19:28:43.903: do something... 1
2019-03-09T19:28:44.909: do something... 2
2019-03-09T19:28:45.928: do something... 3
2019-03-09T19:28:47.928: do something... 4
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 4 attempts.

10.等待策略——组合重试等待时长策略

使用场景：当现有策略不满足使用场景时，可以对多个策略进行组合使用。

public static void main(String[] args) throws ExecutionException,     RetryException {Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(10)).withWaitStrategy(WaitStrategies.join(WaitStrategies.exponentialWait(1000, 100, SECONDS), WaitStrategies.fixedWait(2, SECONDS))).build();retry.call(callableWithResult());
}

同样，看源码才能理解组合策略是什么意思：

public long computeSleepTime(Attempt failedAttempt) {long waitTime = 0L;
//加入Java开发交流君样：756584822一起吹水聊天WaitStrategy waitStrategy;for(Iterator i$ = this.waitStrategies.iterator(); i$.hasNext(); waitTime += waitStrategy.computeSleepTime(failedAttempt)) {waitStrategy = (WaitStrategy)i$.next();}return waitTime;
}

可看出组合策略其实按照多个策略的延迟时间相加得到组合策略的延迟时间。exponentialWait的延迟时间为2，4，8，16，
32…，fixedWait延迟为2，2，2，2，2…,所以总的延迟时间为4，6，10，18，34…

测试输出：

2019-03-09T19:46:45.854: do something... 1
2019-03-09T19:46:49.859: do something... 2
2019-03-09T19:46:55.859: do something... 3
2019-03-09T19:47:05.859: do something... 4
2019-03-09T19:47:23.859: do something... 5
2019-03-09T19:47:57.860: do something... 6
2019-03-09T19:49:03.861: do something... 7
2019-03-09T19:50:45.862: do something... 8

11.监听器——RetryListener实现重试过程细节处理

使用场景：自定义监听器，分别打印重试过程中的细节，未来可更多的用于异步日志记录，亦或是特殊处理。

public class MyRetryListener implements RetryListener {
@Override
public <V> void onRetry(Attempt<V> attempt) {System.out.println(("retry times=" + attempt.getAttemptNumber()));// 距离第一次重试的延迟System.out.println("delay=" + attempt.getDelaySinceFirstAttempt());// 重试结果: 是异常终止, 还是正常返回System.out.println("hasException=" + attempt.hasException());System.out.println("hasResult=" + attempt.hasResult());// 是什么原因导致异常if (attempt.hasException()) {System.out.println("causeBy=" + attempt.getExceptionCause());} else {// 正常返回时的结果System.out.println("result=" + attempt.getResult());}// 增加了额外的异常处理代码try {Object result = attempt.get();System.out.println("rude get=" + result);} catch (ExecutionException e) {System.out.println("this attempt produce exception." + e.getCause());}//加入Java开发交流君样：756584822一起吹水聊天
}

测试：

    public static void main(String[] args) throws ExecutionException, RetryException {Retryer<String> retry = RetryerBuilder.<String>newBuilder().retryIfRuntimeException().withStopStrategy(StopStrategies.stopAfterAttempt(2)).withRetryListener(new MyRetryListener()).build();retry.call(callableWithResult());
}//加入Java开发交流君样：756584822一起吹水聊天

输出：

2019-03-09T16:32:35.097: do something... 1
retry times=1//加入Java开发交流君样：756584822一起吹水聊天
delay=128
hasException=true
hasResult=false
causeBy=java.lang.RuntimeException: Run exception
this attempt produce exception.java.lang.RuntimeException: Run exception
2019-03-09T16:32:35.102: do something... 2
retry times=2
delay=129
hasException=true
hasResult=false
causeBy=java.lang.RuntimeException: Run exception
this attempt produce exception.java.lang.RuntimeException: Run exception
Exception in thread "main" com.github.rholder.retry.RetryException: Retrying failed to complete successfully after 2 attempts.//加入Java开发交流君样：756584822一起吹水聊天

总结

两种方式都是比较优雅的重试策略，Spring-retry配置更简单，实现的功能也相对简单，Guava本身就是谷歌推出的精品java类库，guava-retry也是功能非常强大，相比较于Spring-Retry在是否重试的判断条件上有更多的选择性，可以作为Spring-retry的补充。

最后，祝大家早日学有所成，拿到满意offer

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

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

相关文章

c#3.0关于JSON简单操作的实用帮助类（泛型实现）

c#3.0关于JSON简单操作的实用帮助类（泛型实现）

关于json的操作&#xff0c;网上一搜一大把。避免重复造轮子&#xff0c;整理发布一个笔者在项目开发中经常用到的一个json实用帮助类&#xff0c;泛型实现&#xff0c;非常方便。不废话了&#xff0c;贴代码&#xff1a;1、json操作的帮助类&#xff1a; Codeusing System;usi…
阅读更多...
谁还没个黑历史了。。。 | 今日最佳

谁还没个黑历史了。。。 | 今日最佳

全世界只有3.14 % 的人关注了青少年数学之旅&#xff08;图源网络&#xff0c;侵权删&#xff09;
阅读更多...
ios开发－第二天

ios开发－第二天

1.&#xff03;import可保证无论头文件出现多少次&#xff0c;只包含一次&#xff0c;而#include相反。 2.如果用户不提供文件路径的话&#xff0c;那么argc的值为1&#xff0c;可以用来做是否错误的判断。 3.面向对象和面向过程的区别 面向过程是分析出解决问题的步骤&#xf…
阅读更多...
ASP.NET创建文件并写入内容

ASP.NET创建文件并写入内容

本文从最基本的操作开始&#xff0c;解释在ASP.NET中文件处理的概念&#xff0c;包括如从一个文件中读取内容、如何向一个文件中写入内容和如何删除一个文件。 　　前面已经提到&#xff0c;要想在ASP.NET 页面中进行文件处理&#xff0c;必须要有"System.IO"名称空间…
阅读更多...
C# 虚方法与抽象方法区别

C# 虚方法与抽象方法区别

虚方法是必须要实现的&#xff0c;只有接口或者抽象方法才没有实现体&#xff0c;什么是实现体&#xff0c;就是方法的那对大括号&#xff1a;下面举例&#xff1a;public abstract void Fn1();//定义一个抽象方法 public vitrual void Fn2(){ };//定义一个虚方法(那对大括号必…
阅读更多...
京东面试官：呦，你对中间件 Mycat了解的还挺深~

京东面试官：呦，你对中间件 Mycat了解的还挺深~

1.数据切分概念 数据的切分[&#xff08;Sharding&#xff09;]根据其切分规则的类型&#xff0c;可以分为两种切分模式。一种是按照不同的表&#xff08;或者Schema&#xff09;来切分到不同的数据库&#xff08;主机&#xff09;)之上&#xff0c;这种切可以称之为数据的垂直…
阅读更多...
Redis与Memcached的区别

Redis与Memcached的区别

2019独角兽企业重金招聘Python工程师标准>>> 传统MySQL Memcached架构遇到的问题 实际MySQL是适合进行海量数据存储的&#xff0c;通过Memcached将热点数据加载到cache&#xff0c;加速访问&#xff0c;很多公司都曾经使用过这样的架构&#xff0c;但随着业务数据量…
阅读更多...
“高仿版拼多多”宣告破产！曾一年收割1.3亿用户，如今自救失败负债16亿

“高仿版拼多多”宣告破产！曾一年收割1.3亿用户，如今自救失败负债16亿

全世界只有3.14 % 的人关注了青少年数学之旅又一家改变世界的互联网公司跑路了啊&#xff1f;挣扎数月的淘集集最终也回天乏术了。淘集集并购重组最终失败&#xff0c;供应商何时能拿到被拖欠的货款仍然遥遥无期。这家主打比“拼多多”更下沉市场的社交电商&#xff0c;平台上线…
阅读更多...
处在哪个阶段?

处在哪个阶段?

在职业生涯中&#xff0c;可以划分出多个阶段&#xff0c;但是如下3个阶段也许是最粗糙和实在的&#xff1a; 1、入门级&#xff0c;在别人的领导下可以完成工作。 2、成熟级&#xff0c;可以独立完成工作。 3、精英级&#xff0c;可以领到别人完成工作。 你处在哪个阶段&#…
阅读更多...
.net知识和学习方法系列（十四）TraceListener的应用

.net知识和学习方法系列（十四）TraceListener的应用

在前一往上一往篇文章中&#xff0c;我们用到一个TextWriterTraceListener&#xff0c;它是为监视跟踪和调试输出的侦听器&#xff0c;对于跟踪调试的监听器还有两个&#xff0c;分别是&#xff1a;DefaultTraceListener和EventLogTraceListener&#xff0c;这三个跟踪调试侦听…
阅读更多...
在VS Code中直接调试Web程序，是怎样一种体验？

在VS Code中直接调试Web程序，是怎样一种体验？

前言要在VS Code中启动Chrome或Microsoft Edge中调试任何Web程序&#xff0c;您只需按F5或选择菜单"运行"->"启动调试"来启动会话。你可以选择在Chrome、Edge或Node.js中进行调试。Edge DevTools如果选择了Edge进行调试&#xff0c;你会发现调试工具条上…
阅读更多...
[转]Multiple outputs from T4 made easy

[转]Multiple outputs from T4 made easy

本文转自&#xff1a;http://damieng.com/blog/2009/01/22/multiple-outputs-from-t4-made-easy One of the things I wanted my LINQ to SQL T4 templates to do was be able to split the output into a file-per-entity. Existing solutions used either a separate set of …
阅读更多...
二叉树的深度优先和广度优先遍历

二叉树的深度优先和广度优先遍历

http://steven-hong.javaeye.com/blog/493665图的深度优先搜索法是树的先根遍历的推广&#xff0c;它的基本思想是&#xff1a;从图G的某个顶点v0出发&#xff0c;访问v0&#xff0c;然后选择一个与v0相邻且没被访问过的顶点vi访问&#xff0c;再 从vi出发选择一个与vi相邻且未…
阅读更多...
面试官问：你做过什么Java线程池实践，我写了一篇博客给他看~

面试官问：你做过什么Java线程池实践，我写了一篇博客给他看~

线程池大家都## 标题很熟悉&#xff0c;无论是平时的业务开发还是框架中间件都会用到&#xff0c;大部分都是基于JDK线程池ThreadPoolExecutor做的封装&#xff0c; 都会牵涉到这几个核心参数的设置&#xff1a;核心线程数&#xff0c;等待(任务)队列&#xff0c;最大线程数&am…
阅读更多...
《硝烟中的Scrum和XP》书摘（1）

《硝烟中的Scrum和XP》书摘（1）

Nokia的Scrum标准&#xff1a;迭代要有固定的时长&#xff08;TimeBox&#xff09;&#xff0c;不能超过六个星期。每一次迭代的结尾&#xff0c;代码必须经过QA的测试。Scrum团队必须有产品负责人&#xff0c;而且团队都清楚这个人是谁。产品负责人必须有产品的Backlog&#x…
阅读更多...
【Blog.Idp开源】支持在线密码找回

【Blog.Idp开源】支持在线密码找回

&#xff08;一个做认证平台&#xff0c;必须会遇到的一个问题&#xff09;BCVP框架&#xff0c;是基于:ASP.NETCore5.0VUE.jsIdentityServer4等核心技术&#xff0c;实现的前后端分离与动态认证鉴权一体化平台。01密码找回认证中心绕不开的话题Architecture Design.无论你是自…
阅读更多...
我的狗丢了，所以我能加你微信吗？ | 今日最佳

我的狗丢了，所以我能加你微信吗？ | 今日最佳

全世界只有3.14 % 的人关注了青少年数学之旅&#xff08;图源网络&#xff0c;侵权删&#xff09;
阅读更多...
Yahoo网站性能最佳体验的34条黄金守则

Yahoo网站性能最佳体验的34条黄金守则

Yahoo!的Exceptional Performance团队为改善Web性能带来最佳实践。他们为此进行了一系列的实验、开发了各种工具、写了大量的文章和博客并在各种会议上参与探讨。最佳实践的核心就是旨在提高网站性能。 Excetional Performance团队总结出了一系列可以提高网站速度的方法。可以分…
阅读更多...
hdu 4597 + uva 10891(一类区间dp)

hdu 4597 + uva 10891(一类区间dp)

题目链接&#xff1a;http://vjudge.net/problem/viewProblem.action?id19461 思路&#xff1a;一类经典的博弈类区间dp,我们令dp[l][r]表示玩家A从区间[l, r]得到的最大值&#xff0c;于是就有dp[l][r] sum[l][r] - min(dp[l i][r], dp[l][r - i]) (i > 1 && i …
阅读更多...
将VC++6.0的代码迁移到VS2005常见问题总结(Window核心编程第五版以前代码在VS2005无法编译的解决方案)...

将VC++6.0的代码迁移到VS2005常见问题总结(Window核心编程第五版以前代码在VS2005无法编译的解决方案)...

额喜新厌旧是男人的通病吧&#xff0c;可是呢VS2005的界面看着的确比VC6.0看着舒服&#xff0c;而且也算用习惯了吧。可是网上现在大部分C/C的代码还是用VC6.0的。这为我们这些菜鸟的学习之路增添了不少障碍&#xff0c;可能有很多朋友在这一步就放弃了吧或者抹黑走下去&#x…
阅读更多...
最新文章

Copyright @ 2022~2023