<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Retry -->
    <dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
    </dependency>

    <!-- Spring Boot Starter AOP -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

</dependencies>

package com.zlp.retry.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
/**
 *  全局重試配置
 */
@Configuration
public class CustomRetryConfig {

    /**
     *
     * 這段代碼定義了一個 `CustomRetryConfig` 類，其中包含一個 `retryTemplate` 方法。該方法用于創(chuàng)建并配置一個 `RetryTemplate` 對象，該對象用于處理重試邏輯。
     *
     * 1. 創(chuàng)建 `RetryTemplate` 實例**：創(chuàng)建一個 `RetryTemplate` 對象。
     * 2. 設置重試策略：使用 `SimpleRetryPolicy` 設置最大重試次數(shù)為5次。
     * 3. 設置延遲策略：使用 `ExponentialBackOffPolicy` 設置初始延遲時間為1000毫秒，每次重試間隔時間乘以2。
     * 4. 應用策略：將重試策略和延遲策略應用到 `RetryTemplate` 對象。
     */
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template = new RetryTemplate();

        // 設置重試策略
        SimpleRetryPolicy policy = new SimpleRetryPolicy();
        policy.setMaxAttempts(5);

        // 設置延遲策略
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000);
        backOffPolicy.setMultiplier(2.0);

        template.setRetryPolicy(policy);
        template.setBackOffPolicy(backOffPolicy);

        return template;
    }
}

/**
 * @Classname OrderService
 * @Date 2024/11/18 21:03
 * @Created by ZouLiPing
 */
public interface OrderService {

    /**
     * 創(chuàng)建訂單
     * @param createOrderReq
     * @return
     */
    String createOrder(CreateOrderReq createOrderReq);
}

package com.zlp.retry.service.impl;

import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.zlp.retry.dto.CreateOrderReq;
import com.zlp.retry.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

import java.util.UUID;

/**
 * @Classname OrderServiceImpl
 * @Date 2024/11/18 21:06
 * @Created by ZouLiPing
 */
@Service
@Slf4j(topic = "OrderServiceImpl")
public class OrderServiceImpl implements OrderService {

    
    @Override
    @Retryable(value = {Exception.class},maxAttempts = 4, backoff = @Backoff(delay = 3000))
    public String createOrder(CreateOrderReq createOrderReq) {
        log.info("createOrder.req createOrderReq:{}", JSON.toJSONString(createOrderReq));
        try {
            log.info("createOrder.deductStock.調用時間={}", DateUtil.formatDateTime(DateUtil.date()));
            // 扣減庫存服務
            this.deductStock(createOrderReq);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return UUID.randomUUID().toString();
    }

    /**
     * 模擬扣減庫存
     */
    private void deductStock(CreateOrderReq createOrderReq) {
        throw new RuntimeException("庫存扣減失敗");
    }


    /**
     * 當重試四次仍未能成功創(chuàng)建訂單時調用此方法進行最終處理
     *
     * @param ex 異常對象，包含重試失敗的原因
     * @param createOrderReq 創(chuàng)建訂單的請求對象，包含訂單相關信息
     * @return 返回處理結果，此處返回"fail"表示最終失敗
     */
    @Recover
    public String recover(Exception ex, CreateOrderReq createOrderReq) {
        // 記錄重試四次后仍失敗的日志，包括異常信息和訂單請求內容
        log.error("recover.resp.重試四次還是失敗.error:{},createOrderReq:{}",ex.getMessage(),JSON.toJSONString(createOrderReq));
        // 處理最終失敗的情況
        // 可以記錄日志,或者是投遞MQ,采用最終一致性的方式處理
        return "fail";
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;

@SpringBootApplication
@EnableRetry
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
@RequiredArgsConstructor
public class RetryController {

    private final OrderService orderService;



    @GetMapping("getRetry")
    public String retry(){
        CreateOrderReq createOrderReq = new CreateOrderReq();
        createOrderReq.setOrderId(UUID.randomUUID().toString());
        createOrderReq.setProductId("SKU001");
        createOrderReq.setCount(10);
        createOrderReq.setMoney(100);
        return orderService.createOrder(createOrderReq);
    }
}

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
@Retryable(
    value = {RuntimeException.class},
    maxAttempts = 3,
    backoff = @Backoff(delay = 1000) // 類級別的配置
)
public class MyService {

    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 5,
        backoff = @Backoff(delay = 500) // 方法級別的配置
    )
    public void retryableMethodWithSpecificConfig() {
        System.out.println("Retrying with specific config...");
        throw new RuntimeException("Simulated exception");
    }

    @Retryable(
        value = {RuntimeException.class}
    )
    public void retryableMethodWithoutSpecificDelay() {
        System.out.println("Retrying without specific delay...");
        throw new RuntimeException("Simulated exception");
    }

    public void nonRetryableMethod() {
        System.out.println("This method does not retry.");
        throw new RuntimeException("Simulated exception");
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template = new RetryTemplate();

        SimpleRetryPolicy policy = new SimpleRetryPolicy();
        policy.setMaxAttempts(4);
        template.setRetryPolicy(policy);

        FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
        fixedBackOffPolicy.setBackOffPeriod(750L);
        template.setBackOffPolicy(fixedBackOffPolicy);

        return template;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class AnotherService {

    @Autowired
    private RetryTemplate retryTemplate;

    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 6, // 方法級別的配置
        backoff = @Backoff(delay = 300) // 方法級別的配置
    )
    public void retryableMethodWithGlobalAndLocalConfig() {
        System.out.println("Retrying with global and local config...");
        throw new RuntimeException("Simulated exception");
    }

    @Retryable(
        value = {RuntimeException.class}
    )
    public void retryableMethodWithOnlyGlobalConfig() {
        System.out.println("Retrying with only global config...");
        throw new RuntimeException("Simulated exception");
    }
}

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    // 適合重試的操作：冪等性強、短時間操作、可恢復的錯誤
    @Retryable(
        value = {RuntimeException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000)
    )
    public void retryableFetchData() {
        System.out.println("Fetching data...");
        // 模擬網絡請求或短暫的外部服務調用
        if (Math.random() > 0.5) {
            throw new RuntimeException("Simulated transient network error");
        }
    }

    // 不適合重試的操作：冪等性不可保證、長時間運行
    public void nonRetryableLongRunningTask() {
        System.out.println("Starting long-running task...");
        try {
            Thread.sleep(10000); // 模擬長時間運行的任務
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Long-running task completed.");
    }

    // 不適合重試的操作：涉及敏感信息
    public void updateSensitiveInformation(String sensitiveData) {
        System.out.println("Updating sensitive information...");
        // 這里假設更新操作不是冪等的，也不應該重試
        throw new RuntimeException("Simulated failure in updating sensitive information");
    }

    // 不適合重試的操作：已知的永久性錯誤
    public void fetchDataFromNonExistentResource() {
        System.out.println("Fetching data from a non-existent resource...");
        throw new RuntimeException("Permanent error: Resource not found");
    }
}