在单体Spring Boot应用中实现定时外调API

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling // 启用Spring的调度功能
public class MonolithicAppApplication {

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

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.time.ZoneId;

@Service
public class ScheduledApiCallerService {

    private final ExternalApiService externalApiService;

    public ScheduledApiCallerService(ExternalApiService externalApiService) {
        this.externalApiService = externalApiService;
    }

    /**
     * 定时任务：每天印度时间9点15分执行一次
     * cron表达式格式：秒 分 时 日 月 星期
     * ? 表示不指定
     * ZoneId 用于指定时区，确保任务在正确的时间执行
     */
    @Scheduled(cron = "0 15 9 ? * ?", zone = "Asia/Kolkata") // 每天上午9:15（印度时区）
    @Async // 将此方法放入后台线程执行，避免阻塞主线程
    public void checkOrdersAndNotify() {
        System.out.println("Scheduled task started at: " + LocalDate.now(ZoneId.of("Asia/Kolkata")));

        // 示例业务逻辑：检查3天前的订单并发送通知
        LocalDate threeDaysAgo = LocalDate.now().minusDays(3);
        System.out.println("Checking orders placed around: " + threeDaysAgo);

        // 假设这里会从数据库查询符合条件的订单
        // List<Order> ordersToNotify = orderRepository.findByOrderDate(threeDaysAgo);

        // 遍历订单并调用外部API发送通知
        // for (Order order : ordersToNotify) {
            try {
                // 调用实际的外部API发送通知
                externalApiService.sendNotificationForOrder("someOrderId", "someNotificationData");
                System.out.println("Notification sent for order ID: someOrderId");
            } catch (Exception e) {
                System.err.println("Failed to send notification for order ID: someOrderId. Error: " + e.getMessage());
                // 记录错误，可能需要重试机制
            }
        // }
        System.out.println("Scheduled task finished.");
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync; // 启用异步执行
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
@EnableAsync // 启用异步执行
public class MonolithicAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MonolithicAppApplication.class, args);
    }
}

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ExternalApiService {

    private final RestTemplate restTemplate;
    private final WebClient webClient; // 可选，如果使用响应式WebClient

    // 构造函数注入RestTemplate或WebClient
    public ExternalApiService(RestTemplate restTemplate, WebClient.Builder webClientBuilder) {
        this.restTemplate = restTemplate;
        this.webClient = webClientBuilder.baseUrl("http://external-api.com").build(); // 配置外部API的基础URL
    }

    /**
     * 使用 RestTemplate 调用外部 API
     *
     * @param orderId 订单ID
     * @param dataToSend 要发送的数据
     * @return 外部API的响应
     */
    public String sendNotificationForOrder(String orderId, String dataToSend) {
        String apiUrl = "http://external-api.com/notify"; // 外部API的完整URL

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        // 如果外部API需要认证，可以在这里添加认证头，例如：
        // headers.set("Authorization", "Bearer your_token");

        // 构建请求体
        String requestBody = "{\"orderId\": \"" + orderId + "\", \"data\": \"" + dataToSend + "\"}";
        HttpEntity<String> request = new HttpEntity<>(requestBody, headers);

        try {
            // 发送POST请求
            return restTemplate.postForObject(apiUrl, request, String.class);
        } catch (Exception e) {
            System.err.println("Error calling external API with RestTemplate: " + e.getMessage());
            throw new RuntimeException("Failed to call external API", e);
        }
    }

    /**
     * 使用 WebClient 调用外部 API (响应式)
     *
     * @param orderId 订单ID
     * @param dataToSend 要发送的数据
     * @return 外部API的响应 (Mono<String>)
     */
    public String sendNotificationForOrderReactive(String orderId, String dataToSend) {
        // 构建请求体 (通常使用Map或POJO)
        NotificationRequest requestBody = new NotificationRequest(orderId, dataToSend);

        return webClient.post()
                .uri("/notify") // 相对于baseUrl的路径
                .contentType(MediaType.APPLICATION_JSON)
                // 如果外部API需要认证，可以在这里添加认证头
                // .header(HttpHeaders.AUTHORIZATION, "Bearer your_token")
                .bodyValue(requestBody)
                .retrieve()
                .bodyToMono(String.class)
                .doOnError(e -> System.err.println("Error calling external API with WebClient: " + e.getMessage()))
                .block(); // 在定时任务中，通常需要阻塞等待结果
    }

    // 示例请求体POJO
    private static class NotificationRequest {
        public String orderId;
        public String data;

        public NotificationRequest(String orderId, String data) {
            this.orderId = orderId;
            this.data = data;
        }
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class HttpClientConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}