4.0.0 com.example facade-proxy-client-credentials 1.0-SNAPSHOT jar 17 17 UTF-8 com.fasterxml.jackson.core jackson-databind 2.15.3 org.slf4j slf4j-api 2.0.7 org.slf4j slf4j-simple 2.0.7 runtime org.apache.maven.plugins maven-compiler-plugin 3.11.0 17 17 org.apache.maven.plugins maven-shade-plugin 3.5.0 package shade com.example.Main package com.example.internal.config; public class AuthConfig { private final String tokenEndpoint; private final String clientId; private final String clientSecret; private final String scope; // Optional scope public AuthConfig(String tokenEndpoint, String clientId, String clientSecret, String scope) { this.tokenEndpoint = tokenEndpoint; this.clientId = clientId; this.clientSecret = clientSecret; this.scope = scope; } public AuthConfig(String tokenEndpoint, String clientId, String clientSecret) { this(tokenEndpoint, clientId, clientSecret, null); } public String getTokenEndpoint() { return tokenEndpoint; } public String getClientId() { return clientId; } public String getClientSecret() { return clientSecret; } public String getScope() { return scope; } } package com.example.internal.config; public class ProxyConfig { private final String host; private final int port; public ProxyConfig(String host, int port) { this.host = host; this.port = port; } public String getHost() { return host; } public int getPort() { return port; } public boolean isConfigured() { return host != null && !host.isBlank() && port > 0; } } package com.example.internal.config; public class ApiConfig { private final String baseUrl; public ApiConfig(String baseUrl) { this.baseUrl = baseUrl; } public String getBaseUrl() { return baseUrl; } } package com.example.internal; import com.example.internal.config.AuthConfig; import com.example.internal.config.ProxyConfig; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ProxySelector; import java.net.URI; import java.net.URLEncoder; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.charset.StandardCharsets; import java.time.Duration; import java.time.Instant; import java.util.HashMap; import java.util.Map; import java.util.stream.Collectors; public class AuthService { private static final Logger log = LoggerFactory.getLogger(AuthService.class); private static final Duration TOKEN_EXPIRY_BUFFER = Duration.ofSeconds(30); // Refresh token 30 seconds before expiry private final AuthConfig authConfig; private final HttpClient httpClient; private final ObjectMapper objectMapper = new ObjectMapper(); private String cachedToken; private Instant tokenExpiryTime; public AuthService(AuthConfig authConfig, ProxyConfig proxyConfig) { this.authConfig = authConfig; this.httpClient = buildHttpClient(proxyConfig); } private HttpClient buildHttpClient(ProxyConfig proxyConfig) { HttpClient.Builder builder = HttpClient.newBuilder() .version(HttpClient.Version.HTTP_1_1) .connectTimeout(Duration.ofSeconds(10)); if (proxyConfig != null && proxyConfig.isConfigured()) { log.info("Configuring HttpClient with proxy: {}:{}", proxyConfig.getHost(), proxyConfig.getPort()); builder.proxy(ProxySelector.of(new InetSocketAddress(proxyConfig.getHost(), proxyConfig.getPort()))); } else { log.info("Configuring HttpClient without proxy."); } return builder.build(); } public synchronized String getAccessToken() throws IOException, InterruptedException { if (isTokenValid()) { log.debug("Using cached access token."); return cachedToken; } log.info("Fetching new access token from {}", authConfig.getTokenEndpoint()); return fetchNewToken(); } private boolean isTokenValid() { return cachedToken != null && Instant.now().isBefore(tokenExpiryTime.minus(TOKEN_EXPIRY_BUFFER)); } private String fetchNewToken() throws IOException, InterruptedException { Map formData = new HashMap<>(); formData.put("grant_type", "client_credentials"); formData.put("client_id", authConfig.getClientId()); formData.put("client_secret", authConfig.getClientSecret()); if (authConfig.getScope() != null && !authConfig.getScope().isBlank()) { formData.put("scope", authConfig.getScope()); } String form = formData.entrySet() .stream() .map(e -> e.getKey() + "=" + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8)) .collect(Collectors.joining("&")); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(authConfig.getTokenEndpoint())) .header("Content-Type", "application/x-www-form-urlencoded") .POST(HttpRequest.BodyPublishers.ofString(form)) .build(); HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() >= 200 && response.statusCode() < 300) { TokenResponse tokenResponse = objectMapper.readValue(response.body(), TokenResponse.class); this.cachedToken = tokenResponse.getAccessToken(); // Calculate expiry time based on 'expires_in' seconds from now this.tokenExpiryTime = Instant.now().plusSeconds(tokenResponse.getExpiresIn()); log.info("Successfully obtained new access token. Expires in {} seconds.", tokenResponse.getExpiresIn()); return this.cachedToken; } else { log.error("Failed to fetch access token. Status: {}, Body: {}", response.statusCode(), response.body()); // Clear cache on failure this.cachedToken = null; this.tokenExpiryTime = null; throw new IOException("Failed to fetch access token: " + response.statusCode() + " " + response.body()); } } // Inner class to map JSON response private static class TokenResponse { @JsonProperty("access_token") private String accessToken; @JsonProperty("expires_in") private long expiresIn; // seconds @JsonProperty("token_type") private String tokenType; // e.g., "Bearer" // Getters are needed for Jackson deserialization public String getAccessToken() { return accessToken; } public long getExpiresIn() { return expiresIn; } public String getTokenType() { return tokenType; } } } package com.example.internal; import com.example.internal.config.ApiConfig; import com.example.internal.config.ProxyConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ProxySelector; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.time.Duration; public class ApiClient { private static final Logger log = LoggerFactory.getLogger(ApiClient.class); private final ApiConfig apiConfig; private final AuthService authService; private final HttpClient httpClient; public ApiClient(ApiConfig apiConfig, AuthService authService, ProxyConfig proxyConfig) { this.apiConfig = apiConfig; this.authService = authService; this.httpClient = buildHttpClient(proxyConfig); } private HttpClient buildHttpClient(ProxyConfig proxyConfig) { HttpClient.Builder builder = HttpClient.newBuilder() .version(HttpClient.Version.HTTP_1_1) .connectTimeout(Duration.ofSeconds(15)) // Slightly longer timeout for API calls .followRedirects(HttpClient.Redirect.NORMAL); if (proxyConfig != null && proxyConfig.isConfigured()) { log.info("Configuring ApiClient HttpClient with proxy: {}:{}", proxyConfig.getHost(), proxyConfig.getPort()); builder.proxy(ProxySelector.of(new InetSocketAddress(proxyConfig.getHost(), proxyConfig.getPort()))); } else { log.info("Configuring ApiClient HttpClient without proxy."); } return builder.build(); } public String get(String path) throws IOException, InterruptedException { return sendRequest(path, "GET", null); } public String post(String path, String requestBody) throws IOException, InterruptedException { return sendRequest(path, "POST", requestBody); } public String put(String path, String requestBody) throws IOException, InterruptedException { return sendRequest(path, "PUT", requestBody); } public String delete(String path) throws IOException, InterruptedException { return sendRequest(path, "DELETE", null); } private String sendRequest(String path, String method, String requestBody) throws IOException, InterruptedException { String accessToken = authService.getAccessToken(); URI uri = URI.create(apiConfig.getBaseUrl() + path); HttpRequest.Builder requestBuilder = HttpRequest.newBuilder() .uri(uri) .header("Authorization", "Bearer " + accessToken) .timeout(Duration.ofSeconds(30)); // Request timeout switch (method.toUpperCase()) { case "GET": requestBuilder.GET(); break; case "POST": requestBuilder.POST(HttpRequest.BodyPublishers.ofString(requestBody != null ? requestBody : "")) .header("Content-Type", "application/json"); // Assuming JSON body break; case "PUT": requestBuilder.PUT(HttpRequest.BodyPublishers.ofString(requestBody != null ? requestBody : "")) .header("Content-Type", "application/json"); // Assuming JSON body break; case "DELETE": requestBuilder.DELETE(); break; default: throw new IllegalArgumentException("Unsupported HTTP method: " + method); } HttpRequest request = requestBuilder.build(); log.info("Sending {} request to {}", method, uri); HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); log.info("Received response with status code: {}", response.statusCode()); if (response.statusCode() >= 200 && response.statusCode() < 300) { return response.body(); } else { log.error("API request failed. Status: {}, URI: {}, Body: {}", response.statusCode(), uri, response.body()); throw new IOException("API request failed with status code " + response.statusCode() + ": " + response.body()); } } } package com.example.facade.dto; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; // Example DTO - replace with actual data structure public class ResourceData { private final String id; private final String name; private final String value; @JsonCreator public ResourceData( @JsonProperty("id") String id, @JsonProperty("name") String name, @JsonProperty("value") String value) { this.id = id; this.name = name; this.value = value; } // Getters are needed for Jackson serialization/deserialization public String getId() { return id; } public String getName() { return name; } public String getValue() { return value; } @Override public String toString() { return "ResourceData{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", value='" + value + '\'' + '}'; } } package com.example.facade; import com.example.facade.dto.ResourceData; import com.example.internal.ApiClient; import com.example.internal.AuthService; import com.example.internal.config.ApiConfig; import com.example.internal.config.AuthConfig; import com.example.internal.config.ProxyConfig; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; public class ThirdPartyApiFacade { private static final Logger log = LoggerFactory.getLogger(ThirdPartyApiFacade.class); private final ApiClient apiClient; private final ObjectMapper objectMapper = new ObjectMapper(); public ThirdPartyApiFacade(ApiConfig apiConfig, AuthConfig authConfig, ProxyConfig proxyConfig) { AuthService authService = new AuthService(authConfig, proxyConfig); this.apiClient = new ApiClient(apiConfig, authService, proxyConfig); log.info("ThirdPartyApiFacade initialized for API base URL: {}", apiConfig.getBaseUrl()); } /** * Fetches a resource by its ID from the third-party API. * * @param resourceId The ID of the resource to fetch. * @return ResourceData object representing the fetched resource. * @throws IOException If communication or parsing fails. * @throws InterruptedException If the request thread is interrupted. */ public ResourceData getResourceById(String resourceId) throws IOException, InterruptedException { log.debug("Facade: Fetching resource with ID: {}", resourceId); String path = "/resources/" + resourceId; // Example path String jsonResponse = apiClient.get(path); try { return objectMapper.readValue(jsonResponse, ResourceData.class); } catch (JsonProcessingException e) { log.error("Facade: Failed to parse JSON response for GET {}: {}", path, jsonResponse, e); throw new IOException("Failed to parse API response", e); } } /** * Creates a new resource via the third-party API. * * @param newData The data for the new resource. * @return ResourceData object representing the created resource (as returned by the API). * @throws IOException If communication or parsing fails. * @throws InterruptedException If the request thread is interrupted. */ public ResourceData createResource(ResourceData newData) throws IOException, InterruptedException { log.debug("Facade: Creating new resource: {}", newData); String path = "/resources"; // Example path String requestBody; try { requestBody = objectMapper.writeValueAsString(newData); } catch (JsonProcessingException e) { log.error("Facade: Failed to serialize request data for POST {}: {}", path, newData, e); throw new IOException("Failed to serialize request data", e); } String jsonResponse = apiClient.post(path, requestBody); try { return objectMapper.readValue(jsonResponse, ResourceData.class); } catch (JsonProcessingException e) { log.error("Facade: Failed to parse JSON response for POST {}: {}", path, jsonResponse, e); throw new IOException("Failed to parse API response", e); } } // Add more facade methods as needed (e.g., updateResource, deleteResource) // public ResourceData updateResource(String resourceId, ResourceData updatedData) throws IOException, InterruptedException { ... } // public void deleteResource(String resourceId) throws IOException, InterruptedException { ... } } package com.example; import com.example.facade.ThirdPartyApiFacade; import com.example.facade.dto.ResourceData; import com.example.internal.config.ApiConfig; import com.example.internal.config.AuthConfig; import com.example.internal.config.ProxyConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Main { private static final Logger log = LoggerFactory.getLogger(Main.class); public static void main(String[] args) { // --- Configuration --- // Replace with your actual configuration values // Use environment variables or a config file in a real application // Proxy Configuration (set host/port or null if no proxy) // Example: ProxyConfig proxyConfig = new ProxyConfig("your-proxy.com", 8080); ProxyConfig proxyConfig = null; // No proxy // ProxyConfig proxyConfig = new ProxyConfig("localhost", 8888); // Example for local proxy like Charles/Fiddler // Authentication Configuration AuthConfig authConfig = new AuthConfig( "https://your-auth-server.com/oauth/token", // Token Endpoint URL "your_client_id", "your_client_secret" // Optional: , "api_scope" // Scope(s) if needed ); // API Configuration ApiConfig apiConfig = new ApiConfig("https://your-third-party-api.com/v1"); // API Base URL // --- Facade Initialization --- ThirdPartyApiFacade apiFacade = new ThirdPartyApiFacade(apiConfig, authConfig, proxyConfig); // --- Using the Facade --- try { // Example: Get a resource log.info("Attempting to get resource '123'..."); ResourceData resource = apiFacade.getResourceById("123"); log.info("Successfully retrieved resource: {}", resource); // Example: Create a resource log.info("Attempting to create a new resource..."); ResourceData newData = new ResourceData(null, "New Item", "Some Value"); // ID might be null or ignored on creation ResourceData createdResource = apiFacade.createResource(newData); log.info("Successfully created resource: {}", createdResource); } catch (Exception e) { log.error("An error occurred while interacting with the API via facade: {}", e.getMessage(), e); // Handle exceptions appropriately (e.g., retry, notify user) } log.info("Application finished."); } }