Currency Conversion with ECB Exchange Rates in Java

Building a currency conversion system using European Central Bank (ECB) exchange rates involves fetching real-time or historical forex data, parsing XML responses, and performing accurate currency calculations.

Understanding ECB Exchange Rate Data

The ECB provides daily reference exchange rates in XML format:

Base currency: EUR (Euro)
Update frequency: Daily around 16:00 CET
Format: XML with cube structure
URL: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml

1. Basic Currency Conversion Setup

Domain Models

import java.math.BigDecimal; import java.math.RoundingMode; import java.time.LocalDate; import java.util.*; public class CurrencyModel { // Currency pair representation public record CurrencyPair(String base, String target) { public static CurrencyPair of(String base, String target) { return new CurrencyPair(base.toUpperCase(), target.toUpperCase()); } @Override public String toString() { return base + "/" + target; } } // Exchange rate record public record ExchangeRate(String currency, BigDecimal rate, LocalDate date) { public ExchangeRate { Objects.requireNonNull(currency, "Currency cannot be null"); Objects.requireNonNull(rate, "Rate cannot be null"); Objects.requireNonNull(date, "Date cannot be null"); } @Override public String toString() { return String.format("%s: %.4f (%s)", currency, rate, date); } } // Exchange rate response public static class ExchangeRateResponse { private final LocalDate date; private final Map<String, ExchangeRate> rates; public ExchangeRateResponse(LocalDate date, Map<String, ExchangeRate> rates) { this.date = date; this.rates = new HashMap<>(rates); } public LocalDate getDate() { return date; } public Map<String, ExchangeRate> getRates() { return Collections.unmodifiableMap(rates); } public Optional<ExchangeRate> getRate(String currency) { return Optional.ofNullable(rates.get(currency.toUpperCase())); } public boolean containsCurrency(String currency) { return rates.containsKey(currency.toUpperCase()); } } }

2. ECB XML Parser Implementation

import org.w3c.dom.*; import javax.xml.parsers.*; import java.io.*; import java.math.BigDecimal; import java.net.HttpURLConnection; import java.net.URL; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.*; public class ECBRateParser { private static final String ECB_DAILY_RATES_URL = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml"; private static final String ECB_HISTORICAL_RATES_URL = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist.xml"; private final DocumentBuilder documentBuilder; public ECBRateParser() { try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); // Security: disable external entity processing factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); factory.setFeature("http://xml.org/sax/features/external-general-entities", false); factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false); factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); this.documentBuilder = factory.newDocumentBuilder(); } catch (Exception e) { throw new RuntimeException("Failed to create XML parser", e); } } public CurrencyModel.ExchangeRateResponse fetchDailyRates() throws RateFetchException { try { String xmlContent = fetchXmlContent(ECB_DAILY_RATES_URL); return parseRatesFromXml(xmlContent); } catch (Exception e) { throw new RateFetchException("Failed to fetch daily rates", e); } } public Map<LocalDate, CurrencyModel.ExchangeRateResponse> fetchHistoricalRates() throws RateFetchException { try { String xmlContent = fetchXmlContent(ECB_HISTORICAL_RATES_URL); return parseHistoricalRatesFromXml(xmlContent); } catch (Exception e) { throw new RateFetchException("Failed to fetch historical rates", e); } } private String fetchXmlContent(String urlString) throws IOException { HttpURLConnection connection = null; try { URL url = new URL(urlString); connection = (HttpURLConnection) url.openConnection(); connection.setRequestMethod("GET"); connection.setConnectTimeout(10000); connection.setReadTimeout(10000); connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Java Currency Converter)"); int responseCode = connection.getResponseCode(); if (responseCode != 200) { throw new IOException("HTTP error code: " + responseCode); } try (BufferedReader reader = new BufferedReader( new InputStreamReader(connection.getInputStream()))) { StringBuilder content = new StringBuilder(); String line; while ((line = reader.readLine()) != null) { content.append(line); } return content.toString(); } } finally { if (connection != null) { connection.disconnect(); } } } private CurrencyModel.ExchangeRateResponse parseRatesFromXml(String xmlContent) throws Exception { Document document = documentBuilder.parse(new ByteArrayInputStream(xmlContent.getBytes())); document.getDocumentElement().normalize(); // Find the latest time attribute NodeList cubeNodes = document.getElementsByTagName("Cube"); LocalDate rateDate = null; Map<String, CurrencyModel.ExchangeRate> rates = new HashMap<>(); for (int i = 0; i < cubeNodes.getLength(); i++) { Node node = cubeNodes.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { Element element = (Element) node; // Extract date from time attribute if (element.hasAttribute("time")) { String timeStr = element.getAttribute("time"); rateDate = LocalDate.parse(timeStr, DateTimeFormatter.ISO_LOCAL_DATE); } // Extract currency rates if (element.hasAttribute("currency") && element.hasAttribute("rate")) { String currency = element.getAttribute("currency"); BigDecimal rate = new BigDecimal(element.getAttribute("rate")); rates.put(currency, new CurrencyModel.ExchangeRate(currency, rate, rateDate)); } } } if (rateDate == null || rates.isEmpty()) { throw new RateFetchException("No valid rate data found in XML"); } return new CurrencyModel.ExchangeRateResponse(rateDate, rates); } private Map<LocalDate, CurrencyModel.ExchangeRateResponse> parseHistoricalRatesFromXml(String xmlContent) throws Exception { Document document = documentBuilder.parse(new ByteArrayInputStream(xmlContent.getBytes())); document.getDocumentElement().normalize(); Map<LocalDate, CurrencyModel.ExchangeRateResponse> historicalRates = new HashMap<>(); LocalDate currentDate = null; Map<String, CurrencyModel.ExchangeRate> currentRates = new HashMap<>(); NodeList cubeNodes = document.getElementsByTagName("Cube"); for (int i = 0; i < cubeNodes.getLength(); i++) { Node node = cubeNodes.item(i); if (node.getNodeType() == Node.ELEMENT_NODE) { Element element = (Element) node; if (element.hasAttribute("time")) { // Save previous day's rates if we have them if (currentDate != null && !currentRates.isEmpty()) { historicalRates.put(currentDate, new CurrencyModel.ExchangeRateResponse(currentDate, currentRates)); } // Start new day String timeStr = element.getAttribute("time"); currentDate = LocalDate.parse(timeStr, DateTimeFormatter.ISO_LOCAL_DATE); currentRates = new HashMap<>(); } if (element.hasAttribute("currency") && element.hasAttribute("rate") && currentDate != null) { String currency = element.getAttribute("currency"); BigDecimal rate = new BigDecimal(element.getAttribute("rate")); currentRates.put(currency, new CurrencyModel.ExchangeRate(currency, rate, currentDate)); } } } // Don't forget the last day if (currentDate != null && !currentRates.isEmpty()) { historicalRates.put(currentDate, new CurrencyModel.ExchangeRateResponse(currentDate, currentRates)); } return historicalRates; } public static class RateFetchException extends Exception { public RateFetchException(String message) { super(message); } public RateFetchException(String message, Throwable cause) { super(message, cause); } } }

3. Currency Conversion Engine

import java.math.BigDecimal; import java.math.RoundingMode; import java.time.LocalDate; import java.util.*; public class CurrencyConverter { private final ECBRateParser rateParser; private CurrencyModel.ExchangeRateResponse currentRates; private final Map<LocalDate, CurrencyModel.ExchangeRateResponse> historicalRates; private final Set<String> supportedCurrencies; public CurrencyConverter() { this.rateParser = new ECBRateParser(); this.historicalRates = new HashMap<>(); this.supportedCurrencies = new HashSet<>(); initializeSupportedCurrencies(); } private void initializeSupportedCurrencies() { // ECB always uses EUR as base, plus all quoted currencies supportedCurrencies.add("EUR"); supportedCurrencies.addAll(Arrays.asList( "USD", "JPY", "BGN", "CZK", "DKK", "GBP", "HUF", "PLN", "RON", "SEK", "CHF", "ISK", "NOK", "HRK", "RUB", "TRY", "AUD", "BRL", "CAD", "CNY", "HKD", "IDR", "ILS", "INR", "KRW", "MXN", "MYR", "NZD", "PHP", "SGD", "THB", "ZAR" )); } public void refreshRates() throws ECBRateParser.RateFetchException { this.currentRates = rateParser.fetchDailyRates(); // Add EUR to EUR rate (1:1) currentRates.getRates().put("EUR", new CurrencyModel.ExchangeRate("EUR", BigDecimal.ONE, currentRates.getDate())); } public void loadHistoricalData() throws ECBRateParser.RateFetchException { historicalRates.clear(); historicalRates.putAll(rateParser.fetchHistoricalRates()); } public BigDecimal convert(BigDecimal amount, String fromCurrency, String toCurrency) throws ConversionException { return convert(amount, fromCurrency, toCurrency, LocalDate.now()); } public BigDecimal convert(BigDecimal amount, String fromCurrency, String toCurrency, LocalDate date) throws ConversionException { validateInput(amount, fromCurrency, toCurrency); if (fromCurrency.equalsIgnoreCase(toCurrency)) { return amount.setScale(4, RoundingMode.HALF_UP); } CurrencyModel.ExchangeRateResponse rates = getRatesForDate(date); return performConversion(amount, fromCurrency, toCurrency, rates); } private void validateInput(BigDecimal amount, String fromCurrency, String toCurrency) throws ConversionException { if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) { throw new ConversionException("Amount must be non-negative"); } if (!isCurrencySupported(fromCurrency)) { throw new ConversionException("Unsupported source currency: " + fromCurrency); } if (!isCurrencySupported(toCurrency)) { throw new ConversionException("Unsupported target currency: " + toCurrency); } } private CurrencyModel.ExchangeRateResponse getRatesForDate(LocalDate date) throws ConversionException { if (date.isEqual(LocalDate.now()) && currentRates != null) { return currentRates; } if (historicalRates.containsKey(date)) { return historicalRates.get(date); } throw new ConversionException("No exchange rate data available for date: " + date); } private BigDecimal performConversion(BigDecimal amount, String fromCurrency, String toCurrency, CurrencyModel.ExchangeRateResponse rates) throws ConversionException { try { // Since ECB uses EUR as base, we need to convert through EUR BigDecimal fromRate = getRateToEUR(fromCurrency, rates); BigDecimal toRate = getRateToEUR(toCurrency, rates); // Convert: fromCurrency → EUR → toCurrency BigDecimal amountInEUR = fromCurrency.equalsIgnoreCase("EUR") ? amount : amount.divide(fromRate, 10, RoundingMode.HALF_UP); BigDecimal result = toCurrency.equalsIgnoreCase("EUR") ? amountInEUR : amountInEUR.multiply(toRate); return result.setScale(4, RoundingMode.HALF_UP); } catch (ArithmeticException e) { throw new ConversionException("Conversion calculation error", e); } } private BigDecimal getRateToEUR(String currency, CurrencyModel.ExchangeRateResponse rates) throws ConversionException { if (currency.equalsIgnoreCase("EUR")) { return BigDecimal.ONE; } CurrencyModel.ExchangeRate rate = rates.getRate(currency) .orElseThrow(() -> new ConversionException("Exchange rate not found for currency: " + currency)); return rate.rate(); } public boolean isCurrencySupported(String currency) { return supportedCurrencies.contains(currency.toUpperCase()); } public Set<String> getSupportedCurrencies() { return Collections.unmodifiableSet(supportedCurrencies); } public LocalDate getLatestRateDate() { return currentRates != null ? currentRates.getDate() : null; } public Map<String, BigDecimal> getAllRates() { if (currentRates == null) { return Collections.emptyMap(); } Map<String, BigDecimal> rates = new HashMap<>(); currentRates.getRates().forEach((currency, rate) -> { rates.put(currency, rate.rate()); }); return rates; } public static class ConversionException extends Exception { public ConversionException(String message) { super(message); } public ConversionException(String message, Throwable cause) { super(message, cause); } } }

4. Advanced Features and Caching

import java.math.BigDecimal; import java.time.LocalDate; import java.util.*; import java.util.concurrent.*; public class AdvancedCurrencyConverter { private final CurrencyConverter baseConverter; private final Map<LocalDate, CurrencyModel.ExchangeRateResponse> rateCache; private final ScheduledExecutorService scheduler; private final long cacheDurationMinutes; public AdvancedCurrencyConverter() { this.baseConverter = new CurrencyConverter(); this.rateCache = new ConcurrentHashMap<>(); this.scheduler = Executors.newScheduledThreadPool(1); this.cacheDurationMinutes = 60; // Refresh every hour startScheduledRefresh(); } private void startScheduledRefresh() { scheduler.scheduleAtFixedRate(this::refreshCache, 0, cacheDurationMinutes, TimeUnit.MINUTES); } private void refreshCache() { try { baseConverter.refreshRates(); rateCache.clear(); System.out.println("Exchange rates refreshed at: " + new Date()); } catch (Exception e) { System.err.println("Failed to refresh exchange rates: " + e.getMessage()); } } public BigDecimal convertWithFee(BigDecimal amount, String fromCurrency, String toCurrency, BigDecimal feePercent) throws CurrencyConverter.ConversionException { BigDecimal convertedAmount = baseConverter.convert(amount, fromCurrency, toCurrency); BigDecimal fee = convertedAmount.multiply(feePercent).divide(BigDecimal.valueOf(100), 4, RoundingMode.HALF_UP); return convertedAmount.subtract(fee); } public Map<String, BigDecimal> convertToMultiple(BigDecimal amount, String fromCurrency, Set<String> toCurrencies) throws CurrencyConverter.ConversionException { Map<String, BigDecimal> results = new HashMap<>(); for (String toCurrency : toCurrencies) { try { BigDecimal converted = baseConverter.convert(amount, fromCurrency, toCurrency); results.put(toCurrency, converted); } catch (CurrencyConverter.ConversionException e) { System.err.println("Failed to convert to " + toCurrency + ": " + e.getMessage()); } } return results; } public BigDecimal calculatePercentageChange(String currency, LocalDate startDate, LocalDate endDate) throws CurrencyConverter.ConversionException { BigDecimal startRate = getHistoricalRate(currency, startDate); BigDecimal endRate = getHistoricalRate(currency, endDate); return endRate.subtract(startRate) .divide(startRate, 4, RoundingMode.HALF_UP) .multiply(BigDecimal.valueOf(100)); } private BigDecimal getHistoricalRate(String currency, LocalDate date) throws CurrencyConverter.ConversionException { if (!rateCache.containsKey(date)) { // Load historical data if not in cache try { baseConverter.loadHistoricalData(); } catch (ECBRateParser.RateFetchException e) { throw new CurrencyConverter.ConversionException("Failed to load historical data", e); } } CurrencyModel.ExchangeRateResponse rates = rateCache.get(date); if (rates == null) { throw new CurrencyConverter.ConversionException("No rates available for date: " + date); } return rates.getRate(currency) .orElseThrow(() -> new CurrencyConverter.ConversionException("Rate not found for " + currency)) .rate(); } public void shutdown() { scheduler.shutdown(); try { if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) { scheduler.shutdownNow(); } } catch (InterruptedException e) { scheduler.shutdownNow(); Thread.currentThread().interrupt(); } } }

5. Usage Examples and Testing

import java.math.BigDecimal; import java.time.LocalDate; import java.util.Map; import java.util.Set; public class CurrencyConverterDemo { public static void main(String[] args) { try { AdvancedCurrencyConverter converter = new AdvancedCurrencyConverter(); // Basic conversion demoBasicConversion(converter); // Multiple currency conversion demoMultipleConversion(converter); // Historical analysis demoHistoricalAnalysis(converter); // With fees demoConversionWithFees(converter); converter.shutdown(); } catch (Exception e) { System.err.println("Demo failed: " + e.getMessage()); e.printStackTrace(); } } private static void demoBasicConversion(AdvancedCurrencyConverter converter) { try { System.out.println("=== Basic Currency Conversion ==="); BigDecimal amount = new BigDecimal("100.00"); BigDecimal converted = converter.convertWithFee(amount, "USD", "EUR", BigDecimal.ZERO); System.out.printf("%s USD = %s EUR%n", amount, converted); System.out.println("Latest rate date: " + converter.getLatestRateDate()); } catch (CurrencyConverter.ConversionException e) { System.err.println("Conversion error: " + e.getMessage()); } } private static void demoMultipleConversion(AdvancedCurrencyConverter converter) { try { System.out.println("\n=== Multiple Currency Conversion ==="); BigDecimal amount = new BigDecimal("1000.00"); Set<String> targetCurrencies = Set.of("GBP", "JPY", "CAD", "AUD", "CHF"); Map<String, BigDecimal> results = converter.convertToMultiple(amount, "EUR", targetCurrencies); System.out.printf("%s EUR converts to:%n", amount); results.forEach((currency, value) -> System.out.printf(" %s: %s%n", currency, value)); } catch (CurrencyConverter.ConversionException e) { System.err.println("Multiple conversion error: " + e.getMessage()); } } private static void demoHistoricalAnalysis(AdvancedCurrencyConverter converter) { try { System.out.println("\n=== Historical Analysis ==="); LocalDate startDate = LocalDate.now().minusMonths(1); LocalDate endDate = LocalDate.now(); BigDecimal change = converter.calculatePercentageChange("USD", startDate, endDate); System.out.printf("USD/EUR change from %s to %s: %.2f%%%n", startDate, endDate, change); } catch (CurrencyConverter.ConversionException e) { System.err.println("Historical analysis error: " + e.getMessage()); } } private static void demoConversionWithFees(AdvancedCurrencyConverter converter) { try { System.out.println("\n=== Conversion with Fees ==="); BigDecimal amount = new BigDecimal("500.00"); BigDecimal feePercent = new BigDecimal("1.5"); // 1.5% fee BigDecimal withoutFee = converter.convertWithFee(amount, "GBP", "USD", BigDecimal.ZERO); BigDecimal withFee = converter.convertWithFee(amount, "GBP", "USD", feePercent); System.out.printf("%s GBP = %s USD (without fee)%n", amount, withoutFee); System.out.printf("%s GBP = %s USD (with %.2f%% fee)%n", amount, withFee, feePercent); System.out.printf("Fee amount: %s USD%n", withoutFee.subtract(withFee)); } catch (CurrencyConverter.ConversionException e) { System.err.println("Fee conversion error: " + e.getMessage()); } } }

6. Error Handling and Validation

import java.math.BigDecimal; import java.util.regex.Pattern; public class CurrencyValidation { private static final Pattern CURRENCY_PATTERN = Pattern.compile("[A-Z]{3}"); private static final Set<String> VALID_CURRENCIES = Set.of( "EUR", "USD", "JPY", "GBP", "CHF", "CAD", "AUD", "CNY", "HKD", "NZD" ); public static void validateCurrency(String currency) throws ValidationException { if (currency == null || currency.trim().isEmpty()) { throw new ValidationException("Currency code cannot be null or empty"); } if (!CURRENCY_PATTERN.matcher(currency).matches()) { throw new ValidationException("Invalid currency code format: " + currency); } if (!VALID_CURRENCIES.contains(currency.toUpperCase())) { throw new ValidationException("Unsupported currency: " + currency); } } public static void validateAmount(BigDecimal amount) throws ValidationException { if (amount == null) { throw new ValidationException("Amount cannot be null"); } if (amount.compareTo(BigDecimal.ZERO) < 0) { throw new ValidationException("Amount cannot be negative: " + amount); } if (amount.scale() > 4) { throw new ValidationException("Amount has too many decimal places: " + amount); } } public static void validateDateRange(LocalDate start, LocalDate end) throws ValidationException { if (start == null || end == null) { throw new ValidationException("Dates cannot be null"); } if (start.isAfter(end)) { throw new ValidationException("Start date cannot be after end date"); } if (start.isAfter(LocalDate.now())) { throw new ValidationException("Start date cannot be in the future"); } } public static class ValidationException extends Exception { public ValidationException(String message) { super(message); } } }

7. Maven Dependencies

<dependencies> <!-- For XML parsing --> <dependency> <groupId>xerces</groupId> <artifactId>xercesImpl</artifactId> <version>2.12.2</version> </dependency> <!-- For HTTP client (alternative to HttpURLConnection) --> <dependency> <groupId>org.apache.httpcomponents.client5</groupId> <artifactId>httpclient5</artifactId> <version>5.1.3</version> </dependency> <!-- For JSON support (if needed) --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.14.2</version> </dependency> <!-- For testing --> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter</artifactId> <version>5.9.2</version> <scope>test</scope> </dependency> </dependencies>

Key Features Summary

Real-time ECB Rates: Fetches daily exchange rates from ECB
Historical Data: Supports historical rate analysis
Accurate Calculations: Uses BigDecimal for precise financial calculations
Caching: Implements caching for performance
Error Handling: Comprehensive exception handling
Thread Safety: Designed for concurrent usage
Flexible API: Supports single and multiple currency conversions
Fee Calculation: Built-in support for conversion fees
Validation: Input validation and sanitization
Scheduled Updates: Automatic rate refresh

This implementation provides a robust foundation for currency conversion applications that require accurate, up-to-date exchange rates from the European Central Bank.