Integrate ExchangeRate-API in Java
Make API Request
- Construct the URL using your API key. Typically, your API key should be kept secure and not hardcoded directly into the application.
```java
String apiKey = "YOUR_API_KEY";
String urlString = "https://v6.exchangerate-api.com/v6/" + apiKey + "/latest/USD";
```
- Use an HTTP library to make a request to the URL. If using
HttpURLConnection, your code might look like this:
```java
URL url = new URL(urlString);
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
```
To properly handle exceptions, make sure to wrap this in a try-catch block.
Handle the API Response
- Check the response code to ensure the request was successful.
```java
if (responseCode == HttpURLConnection.HTTP_OK) {
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
// Print the response
System.out.println(response.toString());
} else {
System.out.println("GET request failed.");
}
```
- Parse the JSON response to access currency exchange data. Consider using a JSON library such as Google's GSON or Jackson to make JSON handling easier.
```java
// Example using GSON
Gson gson = new Gson();
ExchangeRateResponse exchangeRateResponse = gson.fromJson(response.toString(), ExchangeRateResponse.class);
// Access specific rates
System.out.println("USD to EUR: " + exchangeRateResponse.getRates().get("EUR"));
```
Make sure you have a proper data model to represent the response. An example simple class for the response might look like:
```java
public class ExchangeRateResponse {
private Map<String, Double> rates;
public Map<String, Double> getRates() {
return rates;
}
}
```
Handle Errors and Edge Cases
- Implement error handling to manage any potential issues such as network errors, API limit reached, or invalid responses. A typical approach could be logging the error details and perhaps retrying the request in some cases.
- Consider edge cases like invalid API key, unexpected JSON response structures, etc. Validate your response and ensure that keys exist before accessing them.
