<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 如果需要JSON處理，添加Jackson依賴（通常已包含在starter-web中） -->
</dependencies>

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Bean
public RestTemplate restTemplate() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setConnectTimeout(5000); // 連接超時(shí)5秒
    factory.setReadTimeout(5000);    // 讀取超時(shí)5秒
    return new RestTemplate(factory);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
@Service
public class WeatherService {
    private final RestTemplate restTemplate;
    @Autowired
    public WeatherService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    public String getWeatherData(String city) {
        String url = "https://api.weather.com/data?city={city}";
        // 發(fā)送GET請(qǐng)求，將響應(yīng)解析為String
        String response = restTemplate.getForObject(url, String.class, city);
        return response; // 實(shí)際項(xiàng)目中，應(yīng)解析JSON為對(duì)象
    }
}

public String loginUser(String username, String password) {
    String url = "https://api.example.com/login";
    // 創(chuàng)建請(qǐng)求體（例如Map或自定義對(duì)象）
    Map<String, String> requestBody = new HashMap<>();
    requestBody.put("username", username);
    requestBody.put("password", password);
    // 發(fā)送POST請(qǐng)求，請(qǐng)求體自動(dòng)序列化為JSON
    String response = restTemplate.postForObject(url, requestBody, String.class);
    return response;
}

public class WeatherResponse {
    private String city;
    private int temp;
    // Getters and Setters
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    public int getTemp() { return temp; }
    public void setTemp(int temp) { this.temp = temp; }
}

public WeatherResponse getWeatherData(String city) {
    String url = "https://api.weather.com/data?city={city}";
    WeatherResponse response = restTemplate.getForObject(url, WeatherResponse.class, city);
    return response;
}

import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestClientException;
public WeatherResponse getWeatherData(String city) {
    String url = "https://api.weather.com/data?city={city}";
    try {
        return restTemplate.getForObject(url, WeatherResponse.class, city);
    } catch (HttpClientErrorException e) {
        // 處理客戶端錯(cuò)誤（如參數(shù)無(wú)效）
        System.err.println("客戶端錯(cuò)誤: " + e.getStatusCode());
        return null;
    } catch (HttpServerErrorException e) {
        // 處理服務(wù)端錯(cuò)誤
        System.err.println("服務(wù)端錯(cuò)誤: " + e.getStatusCode());
        return null;
    } catch (RestClientException e) {
        // 處理其他錯(cuò)誤（如超時(shí)）
        System.err.println("請(qǐng)求失敗: " + e.getMessage());
        return null;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class WeatherController {
    private final WeatherService weatherService;
    @Autowired
    public WeatherController(WeatherService weatherService) {
        this.weatherService = weatherService;
    }
    @GetMapping("/weather/{city}")
    public WeatherResponse getWeather(@PathVariable String city) {
        return weatherService.getWeatherData(city);
    }
}

HttpHeaders headers = new HttpHeaders();
headers.set("Authorization", "Bearer token");
HttpEntity<Object> entity = new HttpEntity<>(requestBody, headers);
ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.*;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.web.client.AsyncRestTemplate;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.ObjectMapper;
public abstract class AbstractApiService {
    private static final Logger logger = LoggerFactory.getLogger(AbstractApiService.class);
    protected final RestTemplate syncRestTemplate;
    protected final AsyncRestTemplate asyncRestTemplate;
    private final ObjectMapper objectMapper = new ObjectMapper();
    protected AbstractApiService(RestTemplate restTemplate, AsyncRestTemplate asyncRestTemplate) {
        this.syncRestTemplate = restTemplate;
        this.asyncRestTemplate = asyncRestTemplate;
    }
    // 同步調(diào)用
    protected <T> ResponseEntity<String> executeSync(
            String url, 
            HttpMethod method, 
            HttpHeaders headers, 
            T body) {
        logRequest(url, method, headers, body);
        HttpEntity<T> requestEntity = new HttpEntity<>(body, headers);
        ResponseEntity<String> response = syncRestTemplate.exchange(
            url, method, requestEntity, String.class);
        logResponse(response);
        return response;
    }
    // 異步調(diào)用
    protected <T> ListenableFuture<ResponseEntity<String>> executeAsync(
            String url, 
            HttpMethod method, 
            HttpHeaders headers, 
            T body) {
        logRequest(url, method, headers, body);
        HttpEntity<T> requestEntity = new HttpEntity<>(body, headers);
        ListenableFuture<ResponseEntity<String>> future = asyncRestTemplate.exchange(
            url, method, requestEntity, String.class);
        future.addCallback(
            result -> logResponse(result),
            ex -> logger.error("Async call failed: {}", ex.getMessage())
        );
        return future;
    }
    // JSON格式日志記錄
    private <T> void logRequest(String url, HttpMethod method, HttpHeaders headers, T body) {
        try {
            String logData = String.format(
                "{\"url\":\"%s\", \"method\":\"%s\", \"headers\":%s, \"body\":%s}",
                url, method, objectMapper.writeValueAsString(headers), 
                objectMapper.writeValueAsString(body)
            );
            logger.info("API請(qǐng)求: {}", logData);
        } catch (Exception e) {
            logger.error("請(qǐng)求日志序列化失敗", e);
        }
    }
    private void logResponse(ResponseEntity<String> response) {
        try {
            String logData = String.format(
                "{\"status\":%s, \"headers\":%s, \"body\":%s}",
                response.getStatusCodeValue(),
                objectMapper.writeValueAsString(response.getHeaders()),
                response.getBody()
            );
            logger.info("API響應(yīng): {}", logData);
        } catch (Exception e) {
            logger.error("響應(yīng)日志序列化失敗", e);
        }
    }
}

import org.springframework.http.*;
import org.springframework.stereotype.Service;
@Service
public class BusinessApiService extends AbstractApiService {
    public BusinessApiService(RestTemplate restTemplate, AsyncRestTemplate asyncRestTemplate) {
        super(restTemplate, asyncRestTemplate);
    }
    // 帶請(qǐng)求體的業(yè)務(wù)調(diào)用
    public BusinessResponse callBusinessApi(BusinessRequest request) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("X-API-KEY", "your-api-key");
        headers.setContentType(MediaType.APPLICATION_JSON);
        ResponseEntity<String> response = executeSync(
            "https://api.example.com/business",
            HttpMethod.POST,
            headers,
            request
        );
        return parseResponse(response.getBody(), BusinessResponse.class);
    }
    // GET請(qǐng)求示例
    public BusinessData getBusinessData(String id) {
        String url = "https://api.example.com/data/" + id;
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer token");
        ResponseEntity<String> response = executeSync(
            url, HttpMethod.GET, headers, null
        );
        return parseResponse(response.getBody(), BusinessData.class);
    }
    // 異步調(diào)用示例
    public ListenableFuture<ResponseEntity<String>> asyncFetchData(AsyncRequest request) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        return executeAsync(
            "https://api.example.com/async",
            HttpMethod.POST,
            headers,
            request
        );
    }
    private <T> T parseResponse(String body, Class<T> valueType) {
        try {
            return objectMapper.readValue(body, valueType);
        } catch (Exception e) {
            logger.error("響應(yīng)解析失敗: {}", body, e);
            throw new RuntimeException("API響應(yīng)解析異常");
        }
    }
}
// 請(qǐng)求響應(yīng)對(duì)象示例
public class BusinessRequest {
    private String param1;
    private int param2;
    // getters/setters
}
public class BusinessResponse {
    private String result;
    private int statusCode;
    // getters/setters
}

import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api")
public class BusinessController {
    private final BusinessApiService apiService;
    public BusinessController(BusinessApiService apiService) {
        this.apiService = apiService;
    }
    @PostMapping("/business")
    public BusinessResponse handleBusiness(@RequestBody BusinessRequest request) {
        return apiService.callBusinessApi(request);
    }
    @GetMapping("/data/{id}")
    public BusinessData getData(@PathVariable String id) {
        return apiService.getBusinessData(id);
    }
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class ScheduledTasks {
    private final BusinessApiService apiService;
    public ScheduledTasks(BusinessApiService apiService) {
        this.apiService = apiService;
    }
    @Scheduled(fixedRate = 3600000) // 每小時(shí)執(zhí)行
    public void hourlySync() {
        BusinessRequest request = new BusinessRequest();
        // 設(shè)置請(qǐng)求參數(shù)
        BusinessResponse response = apiService.callBusinessApi(request);
        // 處理響應(yīng)
    }
}