diff --git a/docs/demo.sql b/docs/demo.sql index 5d678f0..1498ad0 100644 --- a/docs/demo.sql +++ b/docs/demo.sql @@ -3,8 +3,7 @@ CREATE DATABASE demo; USE demo; CREATE TABLE fail_order -( - `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键', +(`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键', `order_id` varchar(255) NOT NULL COMMENT '订单Id', `source_id` int NOT NULL COMMENT '来源Id', `scene_name` varchar(255) NOT NULL COMMENT '场景名称', diff --git a/pom.xml b/pom.xml index 1805566..1385a65 100644 --- a/pom.xml +++ b/pom.xml @@ -10,7 +10,7 @@ com.example - example + example1 1.0.0 example Demo project for Spring Boot @@ -38,17 +38,17 @@ com.aizuda easy-retry-client-starter - 2.6.1 + 3.1.0-SNAPSHOT com.aizuda easy-retry-client-core - 2.6.1 + 3.1.0-SNAPSHOT com.aizuda easy-retry-client-job-core - 2.6.1 + 3.1.0-SNAPSHOT org.freemarker diff --git a/src/main/java/com/example/easy/retry/controller/LocalAndRemoteRetryController.java b/src/main/java/com/example/easy/retry/controller/LocalAndRemoteRetryController.java index 6c91fe0..f27a583 100644 --- a/src/main/java/com/example/easy/retry/controller/LocalAndRemoteRetryController.java +++ b/src/main/java/com/example/easy/retry/controller/LocalAndRemoteRetryController.java @@ -39,4 +39,79 @@ public class LocalAndRemoteRetryController { @RequestParam("params") String params) { localRemoteService.remoteRetryWithLocalRemote(params); } + + @GetMapping("/localRetryWithTwoRetryMethod") + /** + * + * 方法内部存在两个串行的方法retryMethod1、retryMethod1 如下所属 + * public boolean localRetryWithTwoRetryMethod(final String params) { + * retryHandler.retryMethod1(params); + * retryHandler.retryMethod1(params); + * return true; + * } + * params: 1 => 则retryMethod1触发重试 + * params: 2 => 则retryMethod2触发重试 + * params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试 + * + */ + @Operation( + summary = "N个串行执行的方法触发重试的场景", + description = "方法内部存在两个串行的方法retryMethod1、retryMethod1\n" + + "params: 1 => 则retryMethod1触发重试\n" + + "params: 2 => 则retryMethod2触发重试\n" + + "params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试" + ) + public boolean localRetryWithTwoRetryMethod(@RequestParam("params") String params) { + return localRemoteService.localRetryWithTwoRetryMethod(params); + } + + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, + * 只执行入口方法重试 + */ + @GetMapping("/localRetryWithPropagationRequired") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试" + ) + public boolean localRetryWithPropagationRequired(@RequestParam("params") String params) { + return localRemoteService.localRetryWithPropagationRequired(params); + } + + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW, + * 外部和内部方法都触发重试 + */ + @GetMapping("/localRetryWithPropagationRequiredNew") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试" + ) + public boolean localRetryWithPropagationRequiredNew(@RequestParam("params") String params) { + return localRemoteService.localRetryWithPropagationRequiredNew(params); + } + + /** + * 内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch1") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试" + ) + public boolean localRetryWithTryCatch1(@RequestParam("params") String params) { + return localRemoteService.localRetryWithTryCatch1(params); + } + + /** + * 内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch2") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试" + ) + public boolean localRetryWithTryCatch2(@RequestParam("params") String params) { + return localRemoteService.localRetryWithTryCatch2(params); + } } diff --git a/src/main/java/com/example/easy/retry/controller/LocalRetryController.java b/src/main/java/com/example/easy/retry/controller/LocalRetryController.java index 4f383b1..8e741ff 100644 --- a/src/main/java/com/example/easy/retry/controller/LocalRetryController.java +++ b/src/main/java/com/example/easy/retry/controller/LocalRetryController.java @@ -38,11 +38,11 @@ public class LocalRetryController { @GetMapping("/localRetryWithAnnoOnInterface") @Operation( - summary = "@Retryable在接口上执行重试" + summary = "@Retryable在接口上执行重试" ) public void localRetryWithAnnoOnInterface( - @Parameter(name = "params", description = "测试参数", in = ParameterIn.QUERY, - schema = @Schema(type = "string", description = "测试参数")) + @Parameter(name = "params", description = "测试参数", in = ParameterIn.QUERY, + schema = @Schema(type = "string", description = "测试参数")) @RequestParam("params") String params) { localRetryService.localRetryWithAnnoOnInterface(params); } @@ -106,9 +106,84 @@ public class LocalRetryController { */ @Operation( description = "指定自定义的异常处理类", - summary ="🥇什么是自定义的异常处理类: https://www.easyretry.com/pages/540554/#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%96%B9%E6%B3%95%E6%89%A7%E8%A1%8C%E5%99%A8" + summary = "🥇什么是自定义的异常处理类: https://www.easyretry.com/pages/540554/#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%96%B9%E6%B3%95%E6%89%A7%E8%A1%8C%E5%99%A8" ) - public boolean localRetryWithRetryMethod(@RequestBody OrderVo orderVo){ - return localRetryService.localRetryWithRetryMethod(orderVo); + public boolean localRetryWithRetryMethod(@RequestBody OrderVo orderVo) { + return localRetryService.localRetryWithRetryMethod(orderVo); + } + + @GetMapping("/localRetryWithTwoRetryMethod") + /** + * + * 方法内部存在两个串行的方法retryMethod1、retryMethod1 如下所属 + * public boolean localRetryWithTwoRetryMethod(final String params) { + * retryHandler.retryMethod1(params); + * retryHandler.retryMethod1(params); + * return true; + * } + * params: 1 => 则retryMethod1触发重试 + * params: 2 => 则retryMethod2触发重试 + * params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试 + * + */ + @Operation( + summary = "N个串行执行的方法触发重试的场景", + description = "方法内部存在两个串行的方法retryMethod1、retryMethod1\n" + + "params: 1 => 则retryMethod1触发重试\n" + + "params: 2 => 则retryMethod2触发重试\n" + + "params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试" + ) + public boolean localRetryWithTwoRetryMethod(@RequestParam("params") String params) { + return localRetryService.localRetryWithTwoRetryMethod(params); + } + + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, + * 只执行入口方法重试 + */ + @GetMapping("/localRetryWithPropagationRequired") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试" + ) + public boolean localRetryWithPropagationRequired(@RequestParam("params") String params) { + return localRetryService.localRetryWithPropagationRequired(params); + } + + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW, + * 外部和内部方法都触发重试 + */ + @GetMapping("/localRetryWithPropagationRequiredNew") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试" + ) + public boolean localRetryWithPropagationRequiredNew(@RequestParam("params") String params) { + return localRetryService.localRetryWithPropagationRequiredNew(params); + } + + /** + * 内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch1") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试" + ) + public boolean localRetryWithTryCatch1(@RequestParam("params") String params) { + return localRetryService.localRetryWithTryCatch1(params); + } + + /** + * 内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch2") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试" + ) + public boolean localRetryWithTryCatch2(@RequestParam("params") String params) { + return localRetryService.localRetryWithTryCatch2(params); } } diff --git a/src/main/java/com/example/easy/retry/controller/RemoteRetryController.java b/src/main/java/com/example/easy/retry/controller/RemoteRetryController.java index 3135c78..b80f8c9 100644 --- a/src/main/java/com/example/easy/retry/controller/RemoteRetryController.java +++ b/src/main/java/com/example/easy/retry/controller/RemoteRetryController.java @@ -168,5 +168,78 @@ public class RemoteRetryController { remoteRetryService.remoteRetryWithBizNo(orderVo); } + @GetMapping("/localRetryWithTwoRetryMethod") + /** + * + * 方法内部存在两个串行的方法retryMethod1、retryMethod1 如下所属 + * public boolean localRetryWithTwoRetryMethod(final String params) { + * retryHandler.retryMethod1(params); + * retryHandler.retryMethod1(params); + * return true; + * } + * params: 1 => 则retryMethod1触发重试 + * params: 2 => 则retryMethod2触发重试 + * params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试 + * + */ + @Operation( + summary = "N个串行执行的方法触发重试的场景", + description = "方法内部存在两个串行的方法retryMethod1、retryMethod1\n" + + "params: 1 => 则retryMethod1触发重试\n" + + "params: 2 => 则retryMethod2触发重试\n" + + "params: 3 => 则retryMethod1随机触发重试, 若retryMethod1重试成功，则retryMethod2一定触发重试否则只触发retryMethod1重试" + ) + public boolean localRetryWithTwoRetryMethod(@RequestParam("params") String params) { + return remoteRetryService.localRetryWithTwoRetryMethod(params); + } + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, + * 只执行入口方法重试 + */ + @GetMapping("/localRetryWithPropagationRequired") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED, 只执行入口方法重试" + ) + public boolean localRetryWithPropagationRequired(@RequestParam("params") String params) { + return remoteRetryService.localRetryWithPropagationRequired(params); + } + + /** + * 外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW, + * 外部和内部方法都触发重试 + */ + @GetMapping("/localRetryWithPropagationRequiredNew") + @Operation( + description = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试", + summary = "外部方法传播机制为REQUIRED，内部方法传播机制为REQUIRED_NEW,外部和内部方法都触发重试" + ) + public boolean localRetryWithPropagationRequiredNew(@RequestParam("params") String params) { + return remoteRetryService.localRetryWithPropagationRequiredNew(params); + } + + /** + * 内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch1") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED_NEW，且异常被try catch捕获，内部方法触发重试，外部方法不会触发重试" + ) + public boolean localRetryWithTryCatch1(@RequestParam("params") String params) { + return remoteRetryService.localRetryWithTryCatch1(params); + } + + /** + * 内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试 + */ + @GetMapping("/localRetryWithTryCatch2") + @Operation( + description = "", + summary = "内部方法传播机制为REQUIRED，且异常被try catch捕获，内部方法不会触发重试，外部方法也不会触发重试" + ) + public boolean localRetryWithTryCatch2(@RequestParam("params") String params) { + return remoteRetryService.localRetryWithTryCatch2(params); + } } diff --git a/src/main/java/com/example/easy/retry/controller/WorkflowCallbackController.java b/src/main/java/com/example/easy/retry/controller/WorkflowCallbackController.java index 92cbbbe..527ff2b 100644 --- a/src/main/java/com/example/easy/retry/controller/WorkflowCallbackController.java +++ b/src/main/java/com/example/easy/retry/controller/WorkflowCallbackController.java @@ -1,7 +1,7 @@ package com.example.easy.retry.controller; import com.aizuda.easy.retry.server.model.dto.CallbackParamsDTO; -import io.swagger.annotations.Api; +import io.swagger.v3.oas.annotations.tags.Tag; import lombok.extern.slf4j.Slf4j; import org.springframework.http.HttpHeaders; import org.springframework.web.bind.annotation.*; @@ -16,6 +16,7 @@ import java.util.List; @RestController @RequestMapping("/workflow/callback") @Slf4j +@Tag(name = "工作流回调", description = "工作流回调") public class WorkflowCallbackController { @PostMapping diff --git a/src/main/java/com/example/easy/retry/handler/LocalAndRemoteRetryHandler.java b/src/main/java/com/example/easy/retry/handler/LocalAndRemoteRetryHandler.java new file mode 100644 index 0000000..3be4d28 --- /dev/null +++ b/src/main/java/com/example/easy/retry/handler/LocalAndRemoteRetryHandler.java @@ -0,0 +1,59 @@ +package com.example.easy.retry.handler; + +import com.aizuda.easy.retry.client.core.annotation.Propagation; +import com.aizuda.easy.retry.client.core.annotation.Retryable; +import com.aizuda.easy.retry.client.core.retryer.RetryType; +import org.springframework.stereotype.Component; + +import java.util.Random; + +/** + * @author: xiaowoniu + * @date : 2024-02-05 + * @since : 3.1.0 + */ +@Component +public class LocalAndRemoteRetryHandler { + + @Retryable(scene = "localRetryWithTwoRetryMethod1", retryStrategy = RetryType.LOCAL_REMOTE) + public void retryMethod1(String params) { + System.out.println("localRetryWithTwoRetryMethod1"); + if (params.equals("1")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + int random = new Random().nextInt(10); + if (random % 3 == 0) { + System.out.println("localRetryWithTwoRetryMethod1 is success"); + return; + } + + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetryWithTwoRetryMethod2", retryStrategy = RetryType.LOCAL_REMOTE) + public void retryMethod2(String params) { + System.out.println("localRetryWithTwoRetryMethod2"); + if (params.equals("2")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetryWithRequires", retryStrategy = RetryType.LOCAL_REMOTE) + public void localRetryWithRequires(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } + + @Retryable(scene = "localRetryWithRequiresNew", retryStrategy = RetryType.LOCAL_REMOTE, propagation = Propagation.REQUIRES_NEW) + public void localRetryWithRequiresNew(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } +} diff --git a/src/main/java/com/example/easy/retry/handler/OnlyLocalRetryHandler.java b/src/main/java/com/example/easy/retry/handler/OnlyLocalRetryHandler.java new file mode 100644 index 0000000..3696c74 --- /dev/null +++ b/src/main/java/com/example/easy/retry/handler/OnlyLocalRetryHandler.java @@ -0,0 +1,59 @@ +package com.example.easy.retry.handler; + +import com.aizuda.easy.retry.client.core.annotation.Propagation; +import com.aizuda.easy.retry.client.core.annotation.Retryable; +import com.aizuda.easy.retry.client.core.retryer.RetryType; +import org.springframework.stereotype.Component; + +import java.util.Random; + +/** + * @author: xiaowoniu + * @date : 2024-02-05 + * @since : 3.1.0 + */ +@Component +public class OnlyLocalRetryHandler { + + @Retryable(scene = "localRetryWithTwoRetryMethod1", retryStrategy = RetryType.ONLY_LOCAL) + public void retryMethod1(String params) { + System.out.println("localRetryWithTwoRetryMethod1"); + if (params.equals("1")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + int random = new Random().nextInt(10); + if (random % 3 == 0) { + System.out.println("localRetryWithTwoRetryMethod1 is success"); + return; + } + + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetryWithTwoRetryMethod2", retryStrategy = RetryType.ONLY_LOCAL) + public void retryMethod2(String params) { + System.out.println("localRetryWithTwoRetryMethod2"); + if (params.equals("2")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetry", retryStrategy = RetryType.ONLY_LOCAL) + public void localRetry(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } + + @Retryable(scene = "localRetryWithRequiresNew", retryStrategy = RetryType.ONLY_LOCAL, propagation = Propagation.REQUIRES_NEW) + public void localRetryWithRequiresNew(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } +} diff --git a/src/main/java/com/example/easy/retry/handler/OnlyRemoteRetryHandler.java b/src/main/java/com/example/easy/retry/handler/OnlyRemoteRetryHandler.java new file mode 100644 index 0000000..6872021 --- /dev/null +++ b/src/main/java/com/example/easy/retry/handler/OnlyRemoteRetryHandler.java @@ -0,0 +1,59 @@ +package com.example.easy.retry.handler; + +import com.aizuda.easy.retry.client.core.annotation.Propagation; +import com.aizuda.easy.retry.client.core.annotation.Retryable; +import com.aizuda.easy.retry.client.core.retryer.RetryType; +import org.springframework.stereotype.Component; + +import java.util.Random; + +/** + * @author: xiaowoniu + * @date : 2024-02-05 + * @since : 3.1.0 + */ +@Component +public class OnlyRemoteRetryHandler { + + @Retryable(scene = "localRetryWithTwoRetryMethod1", retryStrategy = RetryType.ONLY_LOCAL) + public void retryMethod1(String params) { + System.out.println("localRetryWithTwoRetryMethod1"); + if (params.equals("1")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + int random = new Random().nextInt(10); + if (random % 3 == 0) { + System.out.println("localRetryWithTwoRetryMethod1 is success"); + return; + } + + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetryWithTwoRetryMethod2", retryStrategy = RetryType.ONLY_LOCAL) + public void retryMethod2(String params) { + System.out.println("localRetryWithTwoRetryMethod2"); + if (params.equals("2")) { + throw new RuntimeException("抛出异常"); + } + + if (params.equals("3")) { + throw new RuntimeException("抛出异常"); + } + } + + @Retryable(scene = "localRetryWithRequires", retryStrategy = RetryType.ONLY_LOCAL) + public void localRetryWithRequires(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } + + @Retryable(scene = "localRetryWithRequiresNew", retryStrategy = RetryType.ONLY_LOCAL, propagation = Propagation.REQUIRES_NEW) + public void localRetryWithRequiresNew(String params) { + System.out.println("local retry 方法开始执行"); + double i = 1 / 0; + } +} diff --git a/src/main/java/com/example/easy/retry/service/LocalRemoteService.java b/src/main/java/com/example/easy/retry/service/LocalRemoteService.java index 6624a41..58b8a3f 100644 --- a/src/main/java/com/example/easy/retry/service/LocalRemoteService.java +++ b/src/main/java/com/example/easy/retry/service/LocalRemoteService.java @@ -9,4 +9,14 @@ public interface LocalRemoteService { void localRemote(); String remoteRetryWithLocalRemote(String requestId); + + boolean localRetryWithPropagationRequired(String params); + + boolean localRetryWithPropagationRequiredNew(String params); + + boolean localRetryWithTryCatch1(String params); + + boolean localRetryWithTryCatch2(String params); + + boolean localRetryWithTwoRetryMethod(String params); } diff --git a/src/main/java/com/example/easy/retry/service/LocalRetryService.java b/src/main/java/com/example/easy/retry/service/LocalRetryService.java index d36c166..98e762a 100644 --- a/src/main/java/com/example/easy/retry/service/LocalRetryService.java +++ b/src/main/java/com/example/easy/retry/service/LocalRetryService.java @@ -12,6 +12,8 @@ public interface LocalRetryService { void localRetry(String params); + boolean localRetryWithTwoRetryMethod(String params); + @Retryable(scene = "localRetryWithAnnoOnInterface", retryStrategy = RetryType.ONLY_LOCAL) void localRetryWithAnnoOnInterface(String params); @@ -25,4 +27,12 @@ public interface LocalRetryService { boolean localRetryWithRetryMethod(OrderVo orderVo); + boolean localRetryWithPropagationRequired(String params); + + boolean localRetryWithPropagationRequiredNew(String params); + + boolean localRetryWithTryCatch1(String params); + + boolean localRetryWithTryCatch2(String params); + } diff --git a/src/main/java/com/example/easy/retry/service/RemoteRetryService.java b/src/main/java/com/example/easy/retry/service/RemoteRetryService.java index bb0ec63..e661715 100644 --- a/src/main/java/com/example/easy/retry/service/RemoteRetryService.java +++ b/src/main/java/com/example/easy/retry/service/RemoteRetryService.java @@ -24,4 +24,14 @@ public interface RemoteRetryService { boolean remoteRetryWithCompleteCallback(String scene, OrderVo orderVo); boolean remoteRetryWithBizNo(OrderVo orderVo); + + boolean localRetryWithPropagationRequired(String params); + + boolean localRetryWithPropagationRequiredNew(String params); + + boolean localRetryWithTryCatch1(String params); + + boolean localRetryWithTryCatch2(String params); + + boolean localRetryWithTwoRetryMethod(String params); } diff --git a/src/main/java/com/example/easy/retry/service/impl/LocalRemoteServiceImpl.java b/src/main/java/com/example/easy/retry/service/impl/LocalRemoteServiceImpl.java index d469c22..a561d46 100644 --- a/src/main/java/com/example/easy/retry/service/impl/LocalRemoteServiceImpl.java +++ b/src/main/java/com/example/easy/retry/service/impl/LocalRemoteServiceImpl.java @@ -2,7 +2,10 @@ package com.example.easy.retry.service.impl; import com.aizuda.easy.retry.client.core.annotation.Retryable; import com.aizuda.easy.retry.client.core.retryer.RetryType; +import com.example.easy.retry.handler.LocalAndRemoteRetryHandler; import com.example.easy.retry.service.LocalRemoteService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @@ -15,7 +18,10 @@ import java.util.concurrent.TimeUnit; * @since 2.1.0 */ @Service +@RequiredArgsConstructor +@Slf4j public class LocalRemoteServiceImpl implements LocalRemoteService { + private final LocalAndRemoteRetryHandler localAndRemoteRetryHandler; @Override @Retryable(scene = "localRemote", retryStrategy = RetryType.LOCAL_REMOTE) @@ -36,4 +42,50 @@ public class LocalRemoteServiceImpl implements LocalRemoteService { return requestId; } + @Override + @Retryable(scene = "localRetryWithPropagationRequired", retryStrategy = RetryType.LOCAL_REMOTE) + public boolean localRetryWithPropagationRequired(String params) { + localAndRemoteRetryHandler.localRetryWithRequires(params); + return false; + } + + @Override + @Retryable(scene = "localRetryWithPropagationRequiredNew", retryStrategy = RetryType.LOCAL_REMOTE) + public boolean localRetryWithPropagationRequiredNew(String params) { + localAndRemoteRetryHandler.localRetryWithRequiresNew(params); + return false; + } + + @Override + @Retryable(scene = "localRetryWithTryCatch1", retryStrategy = RetryType.LOCAL_REMOTE) + public boolean localRetryWithTryCatch1(String params) { + try { + // 内部方法需要触发重试 + localAndRemoteRetryHandler.localRetryWithRequiresNew(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + return false; + } + + @Override + @Retryable(scene = "localRetryWithTryCatch2", retryStrategy = RetryType.LOCAL_REMOTE) + public boolean localRetryWithTryCatch2(String params) { + // 由于传播机制为{REQUIRED}，异常被捕获,所以内部不会触发重试 + try { + localAndRemoteRetryHandler.localRetryWithRequires(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + + return false; + } + + @Override + public boolean localRetryWithTwoRetryMethod(String params) { + localAndRemoteRetryHandler.retryMethod1(params); + localAndRemoteRetryHandler.retryMethod2(params); + return false; + } + } diff --git a/src/main/java/com/example/easy/retry/service/impl/LocalRetryServiceImpl.java b/src/main/java/com/example/easy/retry/service/impl/LocalRetryServiceImpl.java index 87b88e8..da889b8 100644 --- a/src/main/java/com/example/easy/retry/service/impl/LocalRetryServiceImpl.java +++ b/src/main/java/com/example/easy/retry/service/impl/LocalRetryServiceImpl.java @@ -2,8 +2,11 @@ package com.example.easy.retry.service.impl; import com.aizuda.easy.retry.client.core.retryer.RetryType; import com.example.easy.retry.customized.OrderRetryMethod; +import com.example.easy.retry.handler.OnlyLocalRetryHandler; import com.example.easy.retry.service.LocalRetryService; import com.example.easy.retry.vo.OrderVo; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import com.aizuda.easy.retry.client.core.annotation.Retryable; @@ -14,7 +17,12 @@ import com.example.easy.retry.exception.ParamException; */ @Component +@Slf4j public class LocalRetryServiceImpl implements LocalRetryService { + + @Autowired + private OnlyLocalRetryHandler onlyLocalRetryHandler; + /** * 入门案例 * 我们仅仅需要指定场景值scene就可以给方法赋予重试逻辑 @@ -30,6 +38,13 @@ public class LocalRetryServiceImpl implements LocalRetryService { double i = 1 / 0; } + @Override + public boolean localRetryWithTwoRetryMethod(final String params) { + onlyLocalRetryHandler.retryMethod1(params); + onlyLocalRetryHandler.retryMethod2(params); + return true; + } + @Override public void localRetryWithAnnoOnInterface(final String params) { double i = 1 / 0; @@ -102,4 +117,43 @@ public class LocalRetryServiceImpl implements LocalRetryService { throw new NullPointerException(); } + @Override + @Retryable(scene = "localRetryWithPropagationRequired", retryStrategy = RetryType.ONLY_LOCAL) + public boolean localRetryWithPropagationRequired(String params) { + onlyLocalRetryHandler.localRetry(params); + return false; + } + + @Override + @Retryable(scene = "localRetryWithPropagationRequiredNew", retryStrategy = RetryType.ONLY_LOCAL) + public boolean localRetryWithPropagationRequiredNew(final String params) { + onlyLocalRetryHandler.localRetryWithRequiresNew(params); + return false; + } + + @Override + @Retryable(scene = "localRetryWithTryCatch1", retryStrategy = RetryType.ONLY_LOCAL) + public boolean localRetryWithTryCatch1(String params) { + try { + // 内部方法需要触发重试 + onlyLocalRetryHandler.localRetryWithRequiresNew(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + return false; + } + + @Override + @Retryable(scene = "localRetryWithTryCatch2", retryStrategy = RetryType.ONLY_LOCAL) + public boolean localRetryWithTryCatch2(String params) { + // 由于传播机制为{REQUIRED}，异常被捕获,所以内部不会触发重试 + try { + onlyLocalRetryHandler.localRetry(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + + return false; + } + } diff --git a/src/main/java/com/example/easy/retry/service/impl/RemoteRetryServiceImpl.java b/src/main/java/com/example/easy/retry/service/impl/RemoteRetryServiceImpl.java index 7e50574..4623e32 100644 --- a/src/main/java/com/example/easy/retry/service/impl/RemoteRetryServiceImpl.java +++ b/src/main/java/com/example/easy/retry/service/impl/RemoteRetryServiceImpl.java @@ -6,7 +6,10 @@ import java.util.concurrent.TimeUnit; import cn.hutool.core.lang.Assert; import com.aizuda.easy.retry.client.core.intercepter.RetrySiteSnapshot; import com.aizuda.easy.retry.common.core.enums.RetryStatusEnum; +import com.example.easy.retry.handler.OnlyRemoteRetryHandler; import com.example.easy.retry.service.RemoteRetryService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import com.aizuda.easy.retry.client.core.annotation.Retryable; @@ -22,8 +25,10 @@ import com.example.easy.retry.vo.OrderVo; * easy-retry中的远程重试 */ @Component +@Slf4j +@RequiredArgsConstructor public class RemoteRetryServiceImpl implements RemoteRetryService { - + private final OnlyRemoteRetryHandler onlyRemoteRetryHandler; /** * 定义一个最基本的远程重试方法 */ @@ -91,6 +96,49 @@ public class RemoteRetryServiceImpl implements RemoteRetryService { throw new NullPointerException(); } + @Override + @Retryable(scene = "localRetryWithPropagationRequired", retryStrategy = RetryType.LOCAL_REMOTE) + public boolean localRetryWithPropagationRequired(String params) { + onlyRemoteRetryHandler.localRetryWithRequires(params); + return false; + } + + @Override + public boolean localRetryWithPropagationRequiredNew(String params) { + onlyRemoteRetryHandler.localRetryWithRequiresNew(params); + return false; + } + + @Override + public boolean localRetryWithTryCatch1(String params) { + try { + // 内部方法需要触发重试 + onlyRemoteRetryHandler.localRetryWithRequiresNew(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + return false; + } + + @Override + public boolean localRetryWithTryCatch2(String params) { + // 由于传播机制为{REQUIRED}，异常被捕获,所以内部不会触发重试 + try { + onlyRemoteRetryHandler.localRetryWithRequires(params); + } catch (Exception e) { + log.error("inner method encountered an exception", e); + } + + return false; + } + + @Override + public boolean localRetryWithTwoRetryMethod(String params) { + onlyRemoteRetryHandler.retryMethod1(params); + onlyRemoteRetryHandler.retryMethod2(params); + return false; + } + /** * 使用自定义的retryCompleteCallback类 OrderCompleteCallback */