<!-- SpringRetry依賴 -->
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.3.3</version>
</dependency>

<!-- SpringRetry需要依賴AOP -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

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

@SpringBootApplication
@EnableRetry // 啟用SpringRetry功能
public class RetryDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(RetryDemoApplication.class, args);
    }
}

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

@Service
public class RemoteServiceClient {
    
    @Retryable(
        value = {ServiceTemporaryException.class}, // 指定觸發(fā)重試的異常類型
        maxAttempts = 3,                           // 最大重試次數(shù)（包括第一次調(diào)用）
        backoff = @Backoff(delay = 1000, multiplier = 2) // 退避策略
    )
    public String callRemoteService(String param) {
        // 模擬遠程服務(wù)調(diào)用，可能會拋出異常
        System.out.println("Calling remote service with parameter: " + param);
        if (Math.random() > 0.7) {
            return "Success response";
        } else {
            throw new ServiceTemporaryException("Service temporarily unavailable");
        }
    }
}

// 自定義的臨時性服務(wù)異常
class ServiceTemporaryException extends RuntimeException {
    public ServiceTemporaryException(String message) {
        super(message);
    }
}

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

@Service
public class ExternalAPIClient {
    
    @Retryable(
        value = {APIException.class},
        maxAttempts = 4,
        backoff = @Backoff(
            delay = 1000,      // 初始延遲時間（毫秒）
            multiplier = 2,     // 延遲倍數(shù)
            maxDelay = 10000   // 最大延遲時間（毫秒）
        )
    )
    public String fetchData() {
        // 調(diào)用外部API的實現(xiàn)
        System.out.println("Attempting to fetch data from external API at " + System.currentTimeMillis());
        double random = Math.random();
        if (random < 0.8) {
            throw new APIException("API temporarily unavailable");
        }
        return "Data successfully fetched";
    }
}

class APIException extends RuntimeException {
    public APIException(String message) {
        super(message);
    }
}

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

@Service
public class PaymentService {
    
    @Retryable(
        value = {PaymentException.class},
        maxAttempts = 3
    )
    public String processPayment(String orderId, double amount) {
        System.out.println("Processing payment for order: " + orderId + ", amount: " + amount);
        // 模擬付款處理，有時會失敗
        if (Math.random() < 0.7) {
            throw new PaymentException("Payment gateway timeout");
        }
        return "Payment successful";
    }
    
    @Recover
    public String recoverPayment(PaymentException e, String orderId, double amount) {
        // 當(dāng)重試耗盡時執(zhí)行恢復(fù)邏輯
        System.out.println("All retries failed for order: " + orderId);
        // 可以記錄日志、發(fā)送通知或執(zhí)行備用操作
        return "Payment processing failed after multiple attempts. Please try again later.";
    }
}

class PaymentException extends RuntimeException {
    public PaymentException(String message) {
        super(message);
    }
}

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

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RetryConfiguration {
    
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template = new RetryTemplate();
        
        // 配置重試策略
        Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
        retryableExceptions.put(NetworkException.class, true);
        retryableExceptions.put(DatabaseException.class, true);
        retryableExceptions.put(UnrecoverableException.class, false);
        
        RetryPolicy retryPolicy = new SimpleRetryPolicy(5, retryableExceptions);
        template.setRetryPolicy(retryPolicy);
        
        // 配置退避策略
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000);
        backOffPolicy.setMultiplier(2.0);
        backOffPolicy.setMaxInterval(10000);
        template.setBackOffPolicy(backOffPolicy);
        
        return template;
    }
}

// 使用RetryTemplate的示例
@Service
public class DataService {
    
    private final RetryTemplate retryTemplate;
    
    @Autowired
    public DataService(RetryTemplate retryTemplate) {
        this.retryTemplate = retryTemplate;
    }
    
    public String fetchData() {
        return retryTemplate.execute(context -> {
            // 在這里執(zhí)行可能失敗的操作
            System.out.println("Attempt number: " + context.getRetryCount());
            if (Math.random() < 0.7) {
                throw new NetworkException("Network connection failed");
            }
            return "Data fetched successfully";
        });
    }
}

class NetworkException extends RuntimeException {
    public NetworkException(String message) {
        super(message);
    }
}

class DatabaseException extends RuntimeException {
    public DatabaseException(String message) {
        super(message);
    }
}

class UnrecoverableException extends RuntimeException {
    public UnrecoverableException(String message) {
        super(message);
    }
}

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

@Service
public class BestPracticeService {
    
    @Retryable(
        value = {TransientException.class},
        maxAttempts = 3,
        exclude = {PermanentException.class},
        backoff = @Backoff(delay = 2000, multiplier = 1.5, random = true)
    )
    public String serviceOperation(String input) {
        System.out.println("Performing operation with input: " + input);
        
        // 模擬業(yè)務(wù)邏輯
        double chance = Math.random();
        if (chance < 0.4) {
            throw new TransientException("Temporary failure");
        } else if (chance < 0.5) {
            throw new PermanentException("Permanent failure");
        }
        
        return "Operation completed successfully";
    }
    
    @Recover
    public String fallbackMethod(TransientException e, String input) {
        System.out.println("All retries failed for input: " + input);
        // 實現(xiàn)降級邏輯
        return "Using fallback response for: " + input;
    }
}

class TransientException extends RuntimeException {
    public TransientException(String message) {
        super(message);
    }
}

class PermanentException extends RuntimeException {
    public PermanentException(String message) {
        super(message);
    }
}