在单体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();

    }

}