Merge branch '3.x'

# Conflicts:
#	pom.xml
#	src/main/java/com/example/easy/retry/controller/LocalAndRemoteRetryController.java
#	src/main/java/com/example/easy/retry/controller/LocalRetryController.java
#	src/main/java/com/example/easy/retry/service/LocalRemoteService.java

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 '场景名称',

pom.xml

@@ -10,7 +10,7 @@
     </parent>
 
     <groupId>com.example</groupId>
-    <artifactId>example</artifactId>
+    <artifactId>example1</artifactId>
     <version>1.0.0</version>
     <name>example</name>
     <description>Demo project for Spring Boot</description>
@@ -38,17 +38,17 @@
         <dependency>
             <groupId>com.aizuda</groupId>
             <artifactId>easy-retry-client-starter</artifactId>
-            <version>2.6.1</version>
+            <version>3.1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>com.aizuda</groupId>
             <artifactId>easy-retry-client-core</artifactId>
-            <version>2.6.1</version>
+            <version>3.1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>com.aizuda</groupId>
             <artifactId>easy-retry-client-job-core</artifactId>
-            <version>2.6.1</version>
+            <version>3.1.0-SNAPSHOT</version>
         </dependency>
         <dependency>
             <groupId>org.freemarker</groupId>

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);
+    }
 }

src/main/java/com/example/easy/retry/controller/LocalRetryController.java

@@ -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){
+    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);
+    }
 }

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);
+    }
 }

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

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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);
 }

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);
+
 }

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);
 }

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;
+    }
+
 }

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;
+    }
+
 }

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
      */