MACRO NEPAL
Mollie Payments in Java: Complete Implementation Guide
awiskar acharya
November 22, 2025
3:20 pm

Introduction to Mollie Payments

Mollie is a popular European payment service provider that offers easy integration for various payment methods. This guide covers building a comprehensive Java client for Mollie's API, supporting payments, refunds, subscriptions, and webhook handling.

Key Features

  • Payment Processing for multiple payment methods
  • Refund Management for processing returns
  • Subscription Handling for recurring payments
  • Webhook Integration for payment status updates
  • Customer Management for storing payment details
  • Order Management for complex payment flows

Dependencies and Setup

Maven Configuration

<properties>
<okhttp.version>4.12.0</okhttp.version>
<jackson.version>2.15.2</jackson.version>
<spring.boot.version>2.7.0</spring.boot.version>
</properties>
<dependencies>
<!-- HTTP Client -->
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>${okhttp.version}</version>
</dependency>
<!-- JSON Processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>${jackson.version}</version>
</dependency>
<!-- Spring Boot (Optional) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring.boot.version}</version>
<optional>true</optional>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.7</version>
</dependency>
<!-- Testing -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.9.3</version>
<scope>test</scope>
</dependency>
</dependencies>

Core Mollie Client Implementation

Main Mollie Client

package com.mollie.client;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import okhttp3.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class MollieClient {
private static final Logger logger = LoggerFactory.getLogger(MollieClient.class);
private final String apiKey;
private final boolean testMode;
private final OkHttpClient httpClient;
private final ObjectMapper objectMapper;
private final String baseUrl;
public MollieClient(String apiKey) {
this(apiKey, true);
}
public MollieClient(String apiKey, boolean testMode) {
this.apiKey = apiKey;
this.testMode = testMode;
this.objectMapper = new ObjectMapper();
this.httpClient = new OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(60, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build();
this.baseUrl = "https://api.mollie.com/v2";
}
/**
* Execute API request with authentication
*/
private Response executeRequest(Request request) throws MollieException {
try {
Response response = httpClient.newCall(request).execute();
if (!response.isSuccessful()) {
handleErrorResponse(response);
}
return response;
} catch (IOException e) {
throw new MollieException("API request failed", e);
}
}
/**
* Handle error responses from Mollie API
*/
private void handleErrorResponse(Response response) throws IOException, MollieException {
String errorBody = response.body().string();
logger.error("Mollie API error: {} - {}", response.code(), errorBody);
try {
ErrorResponse errorResponse = objectMapper.readValue(errorBody, ErrorResponse.class);
throw new MollieException(
errorResponse.getDetail() != null ? errorResponse.getDetail() : errorResponse.getTitle(),
response.code()
);
} catch (Exception e) {
throw new MollieException("HTTP " + response.code() + ": " + errorBody, response.code());
}
}
/**
* Create authenticated request builder
*/
private Request.Builder createAuthenticatedRequest() {
return new Request.Builder()
.addHeader("Authorization", "Bearer " + apiKey)
.addHeader("Content-Type", "application/json");
}
/**
* Create a new payment
*/
public Payment createPayment(PaymentRequest paymentRequest) throws MollieException {
try {
String requestBody = objectMapper.writeValueAsString(paymentRequest);
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments")
.post(RequestBody.create(requestBody, MediaType.parse("application/json")))
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Payment.class);
}
} catch (IOException e) {
throw new MollieException("Failed to create payment", e);
}
}
/**
* Get payment by ID
*/
public Payment getPayment(String paymentId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments/" + paymentId)
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Payment.class);
}
} catch (IOException e) {
throw new MollieException("Failed to get payment: " + paymentId, e);
}
}
/**
* List payments with pagination
*/
public PaginatedResponse<Payment> listPayments(int limit, String from) throws MollieException {
try {
HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + "/payments").newBuilder()
.addQueryParameter("limit", String.valueOf(limit));
if (from != null) {
urlBuilder.addQueryParameter("from", from);
}
Request request = createAuthenticatedRequest()
.url(urlBuilder.build())
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, new TypeReference<PaginatedResponse<Payment>>() {});
}
} catch (IOException e) {
throw new MollieException("Failed to list payments", e);
}
}
/**
* Cancel payment (if possible)
*/
public Payment cancelPayment(String paymentId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments/" + paymentId)
.delete()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Payment.class);
}
} catch (IOException e) {
throw new MollieException("Failed to cancel payment: " + paymentId, e);
}
}
/**
* Create a refund
*/
public Refund createRefund(String paymentId, RefundRequest refundRequest) throws MollieException {
try {
String requestBody = objectMapper.writeValueAsString(refundRequest);
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments/" + paymentId + "/refunds")
.post(RequestBody.create(requestBody, MediaType.parse("application/json")))
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Refund.class);
}
} catch (IOException e) {
throw new MollieException("Failed to create refund", e);
}
}
/**
* Get refund by ID
*/
public Refund getRefund(String paymentId, String refundId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments/" + paymentId + "/refunds/" + refundId)
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Refund.class);
}
} catch (IOException e) {
throw new MollieException("Failed to get refund: " + refundId, e);
}
}
/**
* List refunds for a payment
*/
public PaginatedResponse<Refund> listRefunds(String paymentId, int limit, String from) throws MollieException {
try {
HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + "/payments/" + paymentId + "/refunds").newBuilder()
.addQueryParameter("limit", String.valueOf(limit));
if (from != null) {
urlBuilder.addQueryParameter("from", from);
}
Request request = createAuthenticatedRequest()
.url(urlBuilder.build())
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, new TypeReference<PaginatedResponse<Refund>>() {});
}
} catch (IOException e) {
throw new MollieException("Failed to list refunds", e);
}
}
/**
* Cancel refund (if possible)
*/
public Refund cancelRefund(String paymentId, String refundId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/payments/" + paymentId + "/refunds/" + refundId)
.delete()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Refund.class);
}
} catch (IOException e) {
throw new MollieException("Failed to cancel refund: " + refundId, e);
}
}
/**
* Create a customer
*/
public Customer createCustomer(CustomerRequest customerRequest) throws MollieException {
try {
String requestBody = objectMapper.writeValueAsString(customerRequest);
Request request = createAuthenticatedRequest()
.url(baseUrl + "/customers")
.post(RequestBody.create(requestBody, MediaType.parse("application/json")))
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Customer.class);
}
} catch (IOException e) {
throw new MollieException("Failed to create customer", e);
}
}
/**
* Get customer by ID
*/
public Customer getCustomer(String customerId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/customers/" + customerId)
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Customer.class);
}
} catch (IOException e) {
throw new MollieException("Failed to get customer: " + customerId, e);
}
}
/**
* Update customer
*/
public Customer updateCustomer(String customerId, CustomerRequest customerRequest) throws MollieException {
try {
String requestBody = objectMapper.writeValueAsString(customerRequest);
Request request = createAuthenticatedRequest()
.url(baseUrl + "/customers/" + customerId)
.patch(RequestBody.create(requestBody, MediaType.parse("application/json")))
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Customer.class);
}
} catch (IOException e) {
throw new MollieException("Failed to update customer: " + customerId, e);
}
}
/**
* Delete customer
*/
public void deleteCustomer(String customerId) throws MollieException {
try {
Request request = createAuthenticatedRequest()
.url(baseUrl + "/customers/" + customerId)
.delete()
.build();
try (Response response = executeRequest(request)) {
if (!response.isSuccessful()) {
handleErrorResponse(response);
}
}
} catch (IOException e) {
throw new MollieException("Failed to delete customer: " + customerId, e);
}
}
/**
* List customers with pagination
*/
public PaginatedResponse<Customer> listCustomers(int limit, String from) throws MollieException {
try {
HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + "/customers").newBuilder()
.addQueryParameter("limit", String.valueOf(limit));
if (from != null) {
urlBuilder.addQueryParameter("from", from);
}
Request request = createAuthenticatedRequest()
.url(urlBuilder.build())
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, new TypeReference<PaginatedResponse<Customer>>() {});
}
} catch (IOException e) {
throw new MollieException("Failed to list customers", e);
}
}
/**
* Create customer payment
*/
public Payment createCustomerPayment(String customerId, PaymentRequest paymentRequest) throws MollieException {
try {
String requestBody = objectMapper.writeValueAsString(paymentRequest);
Request request = createAuthenticatedRequest()
.url(baseUrl + "/customers/" + customerId + "/payments")
.post(RequestBody.create(requestBody, MediaType.parse("application/json")))
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Payment.class);
}
} catch (IOException e) {
throw new MollieException("Failed to create customer payment", e);
}
}
/**
* List methods available for your account
*/
public PaginatedResponse<Method> listMethods(Double amount, String currency, String resource) throws MollieException {
try {
HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + "/methods").newBuilder();
if (amount != null) {
urlBuilder.addQueryParameter("amount[value]", String.format("%.2f", amount));
}
if (currency != null) {
urlBuilder.addQueryParameter("amount[currency]", currency);
}
if (resource != null) {
urlBuilder.addQueryParameter("resource", resource);
}
Request request = createAuthenticatedRequest()
.url(urlBuilder.build())
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, new TypeReference<PaginatedResponse<Method>>() {});
}
} catch (IOException e) {
throw new MollieException("Failed to list methods", e);
}
}
/**
* Get specific method
*/
public Method getMethod(String methodId, Double amount, String currency) throws MollieException {
try {
HttpUrl.Builder urlBuilder = HttpUrl.parse(baseUrl + "/methods/" + methodId).newBuilder();
if (amount != null && currency != null) {
urlBuilder.addQueryParameter("amount[value]", String.format("%.2f", amount));
urlBuilder.addQueryParameter("amount[currency]", currency);
}
Request request = createAuthenticatedRequest()
.url(urlBuilder.build())
.get()
.build();
try (Response response = executeRequest(request)) {
String responseBody = response.body().string();
return objectMapper.readValue(responseBody, Method.class);
}
} catch (IOException e) {
throw new MollieException("Failed to get method: " + methodId, e);
}
}
// Custom exception
public static class MollieException extends Exception {
private final int statusCode;
public MollieException(String message) {
super(message);
this.statusCode = 0;
}
public MollieException(String message, Throwable cause) {
super(message, cause);
this.statusCode = 0;
}
public MollieException(String message, int statusCode) {
super(message);
this.statusCode = statusCode;
}
public int getStatusCode() {
return statusCode;
}
}
}

Data Models

Core Data Classes

package com.mollie.model;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.time.OffsetDateTime;
import java.util.List;
import java.util.Map;
// Payment Request
@JsonIgnoreProperties(ignoreUnknown = true)
public class PaymentRequest {
private Amount amount;
private String description;
private String redirectUrl;
private String webhookUrl;
private String method;
private Map<String, Object> metadata;
private String customerId;
private String sequenceType;
private String mandateId;
private String locale;
private Map<String, Object> billingAddress;
private Map<String, Object> shippingAddress;
private String orderId;
private Map<String, Object> applicationFee;
private Map<String, Object> profileId;
private Boolean testmode;
// Getters and setters
public Amount getAmount() { return amount; }
public void setAmount(Amount amount) { this.amount = amount; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public String getRedirectUrl() { return redirectUrl; }
public void setRedirectUrl(String redirectUrl) { this.redirectUrl = redirectUrl; }
public String getWebhookUrl() { return webhookUrl; }
public void setWebhookUrl(String webhookUrl) { this.webhookUrl = webhookUrl; }
public String getMethod() { return method; }
public void setMethod(String method) { this.method = method; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
public String getCustomerId() { return customerId; }
public void setCustomerId(String customerId) { this.customerId = customerId; }
public String getSequenceType() { return sequenceType; }
public void setSequenceType(String sequenceType) { this.sequenceType = sequenceType; }
public String getMandateId() { return mandateId; }
public void setMandateId(String mandateId) { this.mandateId = mandateId; }
public String getLocale() { return locale; }
public void setLocale(String locale) { this.locale = locale; }
public Map<String, Object> getBillingAddress() { return billingAddress; }
public void setBillingAddress(Map<String, Object> billingAddress) { this.billingAddress = billingAddress; }
public Map<String, Object> getShippingAddress() { return shippingAddress; }
public void setShippingAddress(Map<String, Object> shippingAddress) { this.shippingAddress = shippingAddress; }
public String getOrderId() { return orderId; }
public void setOrderId(String orderId) { this.orderId = orderId; }
public Map<String, Object> getApplicationFee() { return applicationFee; }
public void setApplicationFee(Map<String, Object> applicationFee) { this.applicationFee = applicationFee; }
public Map<String, Object> getProfileId() { return profileId; }
public void setProfileId(Map<String, Object> profileId) { this.profileId = profileId; }
public Boolean getTestmode() { return testmode; }
public void setTestmode(Boolean testmode) { this.testmode = testmode; }
}
// Payment Response
@JsonIgnoreProperties(ignoreUnknown = true)
class Payment {
private String id;
private String mode;
private OffsetDateTime createdAt;
private String status;
private Boolean isCancelable;
private Amount amount;
private Amount amountRefunded;
private Amount amountRemaining;
private Amount amountCaptured;
private String description;
private String method;
private Map<String, Object> metadata;
private Map<String, Object> details;
private String profileId;
private String sequenceType;
private String redirectUrl;
private String webhookUrl;
private Links links;
private Customer customer;
private String mandateId;
private String subscriptionId;
private String orderId;
private String settlementId;
private String locale;
private Map<String, Object> billingAddress;
private Map<String, Object> shippingAddress;
private Map<String, Object> applicationFee;
private OffsetDateTime expiredAt;
private OffsetDateTime paidAt;
private OffsetDateTime canceledAt;
private OffsetDateTime failedAt;
// Getters and setters
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getMode() { return mode; }
public void setMode(String mode) { this.mode = mode; }
public OffsetDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(OffsetDateTime createdAt) { this.createdAt = createdAt; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public Boolean getIsCancelable() { return isCancelable; }
public void setIsCancelable(Boolean isCancelable) { this.isCancelable = isCancelable; }
public Amount getAmount() { return amount; }
public void setAmount(Amount amount) { this.amount = amount; }
public Amount getAmountRefunded() { return amountRefunded; }
public void setAmountRefunded(Amount amountRefunded) { this.amountRefunded = amountRefunded; }
public Amount getAmountRemaining() { return amountRemaining; }
public void setAmountRemaining(Amount amountRemaining) { this.amountRemaining = amountRemaining; }
public Amount getAmountCaptured() { return amountCaptured; }
public void setAmountCaptured(Amount amountCaptured) { this.amountCaptured = amountCaptured; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public String getMethod() { return method; }
public void setMethod(String method) { this.method = method; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
public Map<String, Object> getDetails() { return details; }
public void setDetails(Map<String, Object> details) { this.details = details; }
public String getProfileId() { return profileId; }
public void setProfileId(String profileId) { this.profileId = profileId; }
public String getSequenceType() { return sequenceType; }
public void setSequenceType(String sequenceType) { this.sequenceType = sequenceType; }
public String getRedirectUrl() { return redirectUrl; }
public void setRedirectUrl(String redirectUrl) { this.redirectUrl = redirectUrl; }
public String getWebhookUrl() { return webhookUrl; }
public void setWebhookUrl(String webhookUrl) { this.webhookUrl = webhookUrl; }
public Links getLinks() { return links; }
public void setLinks(Links links) { this.links = links; }
public Customer getCustomer() { return customer; }
public void setCustomer(Customer customer) { this.customer = customer; }
public String getMandateId() { return mandateId; }
public void setMandateId(String mandateId) { this.mandateId = mandateId; }
public String getSubscriptionId() { return subscriptionId; }
public void setSubscriptionId(String subscriptionId) { this.subscriptionId = subscriptionId; }
public String getOrderId() { return orderId; }
public void setOrderId(String orderId) { this.orderId = orderId; }
public String getSettlementId() { return settlementId; }
public void setSettlementId(String settlementId) { this.settlementId = settlementId; }
public String getLocale() { return locale; }
public void setLocale(String locale) { this.locale = locale; }
public Map<String, Object> getBillingAddress() { return billingAddress; }
public void setBillingAddress(Map<String, Object> billingAddress) { this.billingAddress = billingAddress; }
public Map<String, Object> getShippingAddress() { return shippingAddress; }
public void setShippingAddress(Map<String, Object> shippingAddress) { this.shippingAddress = shippingAddress; }
public Map<String, Object> getApplicationFee() { return applicationFee; }
public void setApplicationFee(Map<String, Object> applicationFee) { this.applicationFee = applicationFee; }
public OffsetDateTime getExpiredAt() { return expiredAt; }
public void setExpiredAt(OffsetDateTime expiredAt) { this.expiredAt = expiredAt; }
public OffsetDateTime getPaidAt() { return paidAt; }
public void setPaidAt(OffsetDateTime paidAt) { this.paidAt = paidAt; }
public OffsetDateTime getCanceledAt() { return canceledAt; }
public void setCanceledAt(OffsetDateTime canceledAt) { this.canceledAt = canceledAt; }
public OffsetDateTime getFailedAt() { return failedAt; }
public void setFailedAt(OffsetDateTime failedAt) { this.failedAt = failedAt; }
}
// Amount
@JsonIgnoreProperties(ignoreUnknown = true)
class Amount {
private String currency;
private String value;
public Amount() {}
public Amount(String currency, String value) {
this.currency = currency;
this.value = value;
}
public Amount(String currency, double value) {
this.currency = currency;
this.value = String.format("%.2f", value);
}
// Getters and setters
public String getCurrency() { return currency; }
public void setCurrency(String currency) { this.currency = currency; }
public String getValue() { return value; }
public void setValue(String value) { this.value = value; }
}
// Links
@JsonIgnoreProperties(ignoreUnknown = true)
class Links {
private String self;
private String checkout;
private String dashboard;
private String documentation;
private String changePaymentState;
private String refunds;
private String capture;
private String settle;
private String customer;
private String mandate;
private String subscription;
private String order;
// Getters and setters
public String getSelf() { return self; }
public void setSelf(String self) { this.self = self; }
public String getCheckout() { return checkout; }
public void setCheckout(String checkout) { this.checkout = checkout; }
public String getDashboard() { return dashboard; }
public void setDashboard(String dashboard) { this.dashboard = dashboard; }
public String getDocumentation() { return documentation; }
public void setDocumentation(String documentation) { this.documentation = documentation; }
public String getChangePaymentState() { return changePaymentState; }
public void setChangePaymentState(String changePaymentState) { this.changePaymentState = changePaymentState; }
public String getRefunds() { return refunds; }
public void setRefunds(String refunds) { this.refunds = refunds; }
public String getCapture() { return capture; }
public void setCapture(String capture) { this.capture = capture; }
public String getSettle() { return settle; }
public void setSettle(String settle) { this.settle = settle; }
public String getCustomer() { return customer; }
public void setCustomer(String customer) { this.customer = customer; }
public String getMandate() { return mandate; }
public void setMandate(String mandate) { this.mandate = mandate; }
public String getSubscription() { return subscription; }
public void setSubscription(String subscription) { this.subscription = subscription; }
public String getOrder() { return order; }
public void setOrder(String order) { this.order = order; }
}
// Customer
@JsonIgnoreProperties(ignoreUnknown = true)
class Customer {
private String id;
private String mode;
private String name;
private String email;
private String locale;
private Map<String, Object> metadata;
private OffsetDateTime createdAt;
private Links links;
// Getters and setters
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getMode() { return mode; }
public void setMode(String mode) { this.mode = mode; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getLocale() { return locale; }
public void setLocale(String locale) { this.locale = locale; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
public OffsetDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(OffsetDateTime createdAt) { this.createdAt = createdAt; }
public Links getLinks() { return links; }
public void setLinks(Links links) { this.links = links; }
}
// Customer Request
@JsonIgnoreProperties(ignoreUnknown = true)
class CustomerRequest {
private String name;
private String email;
private String locale;
private Map<String, Object> metadata;
// Getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getLocale() { return locale; }
public void setLocale(String locale) { this.locale = locale; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
}
// Refund Request
@JsonIgnoreProperties(ignoreUnknown = true)
class RefundRequest {
private Amount amount;
private String description;
private Map<String, Object> metadata;
private Boolean testmode;
// Getters and setters
public Amount getAmount() { return amount; }
public void setAmount(Amount amount) { this.amount = amount; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
public Boolean getTestmode() { return testmode; }
public void setTestmode(Boolean testmode) { this.testmode = testmode; }
}
// Refund
@JsonIgnoreProperties(ignoreUnknown = true)
class Refund {
private String id;
private Amount amount;
private String settlementId;
private OffsetDateTime createdAt;
private String description;
private Map<String, Object> metadata;
private String paymentId;
private String status;
private Links links;
// Getters and setters
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public Amount getAmount() { return amount; }
public void setAmount(Amount amount) { this.amount = amount; }
public String getSettlementId() { return settlementId; }
public void setSettlementId(String settlementId) { this.settlementId = settlementId; }
public OffsetDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(OffsetDateTime createdAt) { this.createdAt = createdAt; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
public String getPaymentId() { return paymentId; }
public void setPaymentId(String paymentId) { this.paymentId = paymentId; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public Links getLinks() { return links; }
public void setLinks(Links links) { this.links = links; }
}
// Method
@JsonIgnoreProperties(ignoreUnknown = true)
class Method {
private String id;
private String description;
private Amount minimumAmount;
private Amount maximumAmount;
private String status;
private Image image;
private Map<String, Object> pricing;
// Getters and setters
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Amount getMinimumAmount() { return minimumAmount; }
public void setMinimumAmount(Amount minimumAmount) { this.minimumAmount = minimumAmount; }
public Amount getMaximumAmount() { return maximumAmount; }
public void setMaximumAmount(Amount maximumAmount) { this.maximumAmount = maximumAmount; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public Image getImage() { return image; }
public void setImage(Image image) { this.image = image; }
public Map<String, Object> getPricing() { return pricing; }
public void setPricing(Map<String, Object> pricing) { this.pricing = pricing; }
}
// Image
@JsonIgnoreProperties(ignoreUnknown = true)
class Image {
private String size1x;
private String size2x;
private String svg;
// Getters and setters
public String getSize1x() { return size1x; }
public void setSize1x(String size1x) { this.size1x = size1x; }
public String getSize2x() { return size2x; }
public void setSize2x(String size2x) { this.size2x = size2x; }
public String getSvg() { return svg; }
public void setSvg(String svg) { this.svg = svg; }
}
// Paginated Response
@JsonIgnoreProperties(ignoreUnknown = true)
class PaginatedResponse<T> {
private Integer count;
private List<T> data;
private Links links;
// Getters and setters
public Integer getCount() { return count; }
public void setCount(Integer count) { this.count = count; }
public List<T> getData() { return data; }
public void setData(List<T> data) { this.data = data; }
public Links getLinks() { return links; }
public void setLinks(Links links) { this.links = links; }
}
// Error Response
@JsonIgnoreProperties(ignoreUnknown = true)
class ErrorResponse {
private String status;
private String title;
private String detail;
private String field;
private Links links;
// Getters and setters
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public String getTitle() { return title; }
public void setTitle(String title) { this.title = title; }
public String getDetail() { return detail; }
public void setDetail(String detail) { this.detail = detail; }
public String getField() { return field; }
public void setField(String field) { this.field = field; }
public Links getLinks() { return links; }
public void setLinks(Links links) { this.links = links; }
}

Payment Service

Comprehensive Payment Service

package com.mollie.service;
import com.mollie.client.MollieClient;
import com.mollie.model.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class PaymentService {
private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
private final MollieClient client;
private final String webhookBaseUrl;
private final String redirectBaseUrl;
public PaymentService(MollieClient client, String webhookBaseUrl, String redirectBaseUrl) {
this.client = client;
this.webhookBaseUrl = webhookBaseUrl;
this.redirectBaseUrl = redirectBaseUrl;
}
/**
* Create a simple payment
*/
public Payment createSimplePayment(double amount, String currency, String description, 
String orderId, Map<String, Object> metadata) throws MollieException {
PaymentRequest request = new PaymentRequest();
request.setAmount(new Amount(currency, amount));
request.setDescription(description);
request.setRedirectUrl(redirectBaseUrl + "/payment/return");
request.setWebhookUrl(webhookBaseUrl + "/webhook/payment");
request.setMetadata(metadata);
if (orderId != null) {
request.setOrderId(orderId);
}
return client.createPayment(request);
}
/**
* Create payment with specific method
*/
public Payment createPaymentWithMethod(double amount, String currency, String description, 
String method, String orderId, Map<String, Object> metadata) throws MollieException {
PaymentRequest request = new PaymentRequest();
request.setAmount(new Amount(currency, amount));
request.setDescription(description);
request.setMethod(method);
request.setRedirectUrl(redirectBaseUrl + "/payment/return");
request.setWebhookUrl(webhookBaseUrl + "/webhook/payment");
request.setMetadata(metadata);
if (orderId != null) {
request.setOrderId(orderId);
}
return client.createPayment(request);
}
/**
* Create recurring payment for customer
*/
public Payment createRecurringPayment(String customerId, double amount, String currency, 
String description, String mandateId, Map<String, Object> metadata) throws MollieException {
PaymentRequest request = new PaymentRequest();
request.setAmount(new Amount(currency, amount));
request.setDescription(description);
request.setCustomerId(customerId);
request.setSequenceType("recurring");
request.setMandateId(mandateId);
request.setMetadata(metadata);
return client.createPayment(request);
}
/**
* Create payment for existing customer
*/
public Payment createCustomerPayment(String customerId, double amount, String currency, 
String description, String method, Map<String, Object> metadata) throws MollieException {
PaymentRequest request = new PaymentRequest();
request.setAmount(new Amount(currency, amount));
request.setDescription(description);
request.setCustomerId(customerId);
request.setMethod(method);
request.setRedirectUrl(redirectBaseUrl + "/payment/return");
request.setWebhookUrl(webhookBaseUrl + "/webhook/payment");
request.setMetadata(metadata);
return client.createCustomerPayment(customerId, request);
}
/**
* Check if payment is successful
*/
public boolean isPaymentSuccessful(String paymentId) throws MollieException {
Payment payment = client.getPayment(paymentId);
return "paid".equals(payment.getStatus());
}
/**
* Check if payment is pending
*/
public boolean isPaymentPending(String paymentId) throws MollieException {
Payment payment = client.getPayment(paymentId);
return "pending".equals(payment.getStatus()) || "open".equals(payment.getStatus());
}
/**
* Check if payment has failed
*/
public boolean isPaymentFailed(String paymentId) throws MollieException {
Payment payment = client.getPayment(paymentId);
return "failed".equals(payment.getStatus()) || "expired".equals(payment.getStatus()) || 
"canceled".equals(payment.getStatus());
}
/**
* Get payment status
*/
public String getPaymentStatus(String paymentId) throws MollieException {
Payment payment = client.getPayment(paymentId);
return payment.getStatus();
}
/**
* Process refund for payment
*/
public Refund processRefund(String paymentId, double amount, String currency, 
String description, Map<String, Object> metadata) throws MollieException {
RefundRequest request = new RefundRequest();
request.setAmount(new Amount(currency, amount));
request.setDescription(description);
request.setMetadata(metadata);
return client.createRefund(paymentId, request);
}
/**
* Process full refund
*/
public Refund processFullRefund(String paymentId, String description, Map<String, Object> metadata) throws MollieException {
Payment payment = client.getPayment(paymentId);
return processRefund(paymentId, 
Double.parseDouble(payment.getAmount().getValue()), 
payment.getAmount().getCurrency(), 
description, metadata);
}
/**
* Get available payment methods for amount
*/
public List<Method> getAvailableMethods(double amount, String currency) throws MollieException {
PaginatedResponse<Method> response = client.listMethods(amount, currency, "orders");
return response.getData();
}
/**
* Check if method is available for amount
*/
public boolean isMethodAvailable(String methodId, double amount, String currency) throws MollieException {
try {
Method method = client.getMethod(methodId, amount, currency);
return "activated".equals(method.getStatus());
} catch (MollieException e) {
if (e.getStatusCode() == 404) {
return false;
}
throw e;
}
}
/**
* Create customer with basic info
*/
public Customer createCustomer(String name, String email, String locale, Map<String, Object> metadata) throws MollieException {
CustomerRequest request = new CustomerRequest();
request.setName(name);
request.setEmail(email);
request.setLocale(locale);
request.setMetadata(metadata);
return client.createCustomer(request);
}
/**
* Update customer information
*/
public Customer updateCustomer(String customerId, String name, String email, Map<String, Object> metadata) throws MollieException {
CustomerRequest request = new CustomerRequest();
request.setName(name);
request.setEmail(email);
request.setMetadata(metadata);
return client.updateCustomer(customerId, request);
}
/**
* Get customer payments
*/
public List<Payment> getCustomerPayments(String customerId, int limit) throws MollieException {
// Note: This would require additional implementation in the client
// For now, we'll list all payments and filter by customer
PaginatedResponse<Payment> payments = client.listPayments(limit, null);
return payments.getData().stream()
.filter(p -> customerId.equals(p.getCustomer() != null ? p.getCustomer().getId() : null))
.toList();
}
/**
* Validate webhook signature (basic implementation)
*/
public boolean validateWebhookSignature(String body, String signature) {
// In a real implementation, you would verify the signature
// This is a simplified version
logger.info("Webhook received with signature: {}", signature);
return true;
}
/**
* Process webhook notification
*/
public WebhookResult processWebhook(String body, String signature) {
try {
if (!validateWebhookSignature(body, signature)) {
return new WebhookResult(false, "Invalid signature");
}
// Parse webhook body
Payment payment = client.getObjectMapper().readValue(body, Payment.class);
String paymentId = payment.getId();
String status = payment.getStatus();
logger.info("Processing webhook for payment {} with status {}", paymentId, status);
// Handle different statuses
switch (status) {
case "paid":
handlePaidPayment(payment);
break;
case "failed":
handleFailedPayment(payment);
break;
case "canceled":
handleCanceledPayment(payment);
break;
case "expired":
handleExpiredPayment(payment);
break;
case "pending":
handlePendingPayment(payment);
break;
default:
logger.warn("Unknown payment status: {}", status);
}
return new WebhookResult(true, "Webhook processed successfully");
} catch (Exception e) {
logger.error("Error processing webhook", e);
return new WebhookResult(false, "Error processing webhook: " + e.getMessage());
}
}
// Webhook handlers
private void handlePaidPayment(Payment payment) {
// Update order status in your system
// Send confirmation email
// Fulfill order
logger.info("Payment {} completed successfully", payment.getId());
// Extract metadata for your business logic
Map<String, Object> metadata = payment.getMetadata();
if (metadata != null) {
String orderId = (String) metadata.get("orderId");
if (orderId != null) {
// Update your order system
logger.info("Updating order {} to paid", orderId);
}
}
}
private void handleFailedPayment(Payment payment) {
// Notify customer
// Update order status
logger.warn("Payment {} failed", payment.getId());
}
private void handleCanceledPayment(Payment payment) {
// Handle canceled payment
logger.info("Payment {} was canceled", payment.getId());
}
private void handleExpiredPayment(Payment payment) {
// Handle expired payment
logger.info("Payment {} expired", payment.getId());
}
private void handlePendingPayment(Payment payment) {
// Handle pending payment (e.g., bank transfer)
logger.info("Payment {} is pending", payment.getId());
}
// Webhook result
public static class WebhookResult {
private final boolean success;
private final String message;
public WebhookResult(boolean success, String message) {
this.success = success;
this.message = message;
}
public boolean isSuccess() { return success; }
public String getMessage() { return message; }
}
}

Spring Boot Integration

Configuration Class

package com.mollie.config;
import com.mollie.client.MollieClient;
import com.mollie.service.PaymentService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MollieConfig {
@Value("${mollie.api.key}")
private String apiKey;
@Value("${mollie.test.mode:true}")
private boolean testMode;
@Value("${app.webhook.base.url}")
private String webhookBaseUrl;
@Value("${app.redirect.base.url}")
private String redirectBaseUrl;
@Bean
public MollieClient mollieClient() {
return new MollieClient(apiKey, testMode);
}
@Bean
public PaymentService paymentService() {
return new PaymentService(mollieClient(), webhookBaseUrl, redirectBaseUrl);
}
}

REST Controller

package com.mollie.controller;
import com.mollie.model.*;
import com.mollie.service.PaymentService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/payments")
public class PaymentController {
private static final Logger logger = LoggerFactory.getLogger(PaymentController.class);
@Autowired
private PaymentService paymentService;
@PostMapping("/create")
public ResponseEntity<Map<String, Object>> createPayment(@RequestBody CreatePaymentRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Payment payment = paymentService.createSimplePayment(
request.getAmount(),
request.getCurrency(),
request.getDescription(),
request.getOrderId(),
request.getMetadata()
);
response.put("success", true);
response.put("paymentId", payment.getId());
response.put("checkoutUrl", payment.getLinks().getCheckout());
response.put("status", payment.getStatus());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to create payment", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@PostMapping("/create-with-method")
public ResponseEntity<Map<String, Object>> createPaymentWithMethod(@RequestBody CreatePaymentMethodRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Payment payment = paymentService.createPaymentWithMethod(
request.getAmount(),
request.getCurrency(),
request.getDescription(),
request.getMethod(),
request.getOrderId(),
request.getMetadata()
);
response.put("success", true);
response.put("paymentId", payment.getId());
response.put("checkoutUrl", payment.getLinks().getCheckout());
response.put("status", payment.getStatus());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to create payment with method", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping("/{paymentId}")
public ResponseEntity<Map<String, Object>> getPayment(@PathVariable String paymentId) {
Map<String, Object> response = new HashMap<>();
try {
Payment payment = paymentService.getPayment(paymentId);
response.put("success", true);
response.put("payment", payment);
response.put("status", payment.getStatus());
response.put("isSuccessful", paymentService.isPaymentSuccessful(paymentId));
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to get payment: {}", paymentId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping("/{paymentId}/status")
public ResponseEntity<Map<String, Object>> getPaymentStatus(@PathVariable String paymentId) {
Map<String, Object> response = new HashMap<>();
try {
String status = paymentService.getPaymentStatus(paymentId);
response.put("success", true);
response.put("paymentId", paymentId);
response.put("status", status);
response.put("isSuccessful", "paid".equals(status));
response.put("isPending", "pending".equals(status) || "open".equals(status));
response.put("isFailed", "failed".equals(status) || "expired".equals(status) || "canceled".equals(status));
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to get payment status: {}", paymentId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@PostMapping("/{paymentId}/refund")
public ResponseEntity<Map<String, Object>> createRefund(
@PathVariable String paymentId,
@RequestBody CreateRefundRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Refund refund = paymentService.processRefund(
paymentId,
request.getAmount(),
request.getCurrency(),
request.getDescription(),
request.getMetadata()
);
response.put("success", true);
response.put("refundId", refund.getId());
response.put("status", refund.getStatus());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to create refund for payment: {}", paymentId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@PostMapping("/{paymentId}/refund/full")
public ResponseEntity<Map<String, Object>> createFullRefund(
@PathVariable String paymentId,
@RequestBody CreateRefundRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Refund refund = paymentService.processFullRefund(
paymentId,
request.getDescription(),
request.getMetadata()
);
response.put("success", true);
response.put("refundId", refund.getId());
response.put("status", refund.getStatus());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to create full refund for payment: {}", paymentId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping("/methods")
public ResponseEntity<Map<String, Object>> getAvailableMethods(
@RequestParam double amount,
@RequestParam String currency) {
Map<String, Object> response = new HashMap<>();
try {
List<Method> methods = paymentService.getAvailableMethods(amount, currency);
response.put("success", true);
response.put("methods", methods);
response.put("count", methods.size());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to get available methods", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@PostMapping("/webhook")
public ResponseEntity<Map<String, Object>> handleWebhook(
@RequestBody String body,
@RequestHeader(value = "Signature", required = false) String signature) {
Map<String, Object> response = new HashMap<>();
try {
PaymentService.WebhookResult result = paymentService.processWebhook(body, signature);
if (result.isSuccess()) {
response.put("success", true);
response.put("message", result.getMessage());
return ResponseEntity.ok(response);
} else {
response.put("success", false);
response.put("error", result.getMessage());
return ResponseEntity.badRequest().body(response);
}
} catch (Exception e) {
logger.error("Failed to process webhook", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
// Request DTOs
public static class CreatePaymentRequest {
private double amount;
private String currency;
private String description;
private String orderId;
private Map<String, Object> metadata;
// Getters and setters
public double getAmount() { return amount; }
public void setAmount(double amount) { this.amount = amount; }
public String getCurrency() { return currency; }
public void setCurrency(String currency) { this.currency = currency; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public String getOrderId() { return orderId; }
public void setOrderId(String orderId) { this.orderId = orderId; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
}
public static class CreatePaymentMethodRequest {
private double amount;
private String currency;
private String description;
private String method;
private String orderId;
private Map<String, Object> metadata;
// Getters and setters
public double getAmount() { return amount; }
public void setAmount(double amount) { this.amount = amount; }
public String getCurrency() { return currency; }
public void setCurrency(String currency) { this.currency = currency; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public String getMethod() { return method; }
public void setMethod(String method) { this.method = method; }
public String getOrderId() { return orderId; }
public void setOrderId(String orderId) { this.orderId = orderId; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
}
public static class CreateRefundRequest {
private double amount;
private String currency;
private String description;
private Map<String, Object> metadata;
// Getters and setters
public double getAmount() { return amount; }
public void setAmount(double amount) { this.amount = amount; }
public String getCurrency() { return currency; }
public void setCurrency(String currency) { this.currency = currency; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Map<String, Object> getMetadata() { return metadata; }
public void setMetadata(Map<String, Object> metadata) { this.metadata = metadata; }
}
}

Customer Management Controller

package com.mollie.controller;
import com.mollie.model.Customer;
import com.mollie.model.CustomerRequest;
import com.mollie.model.PaginatedResponse;
import com.mollie.model.Payment;
import com.mollie.service.PaymentService;
import com.mollie.client.MollieClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/customers")
public class CustomerController {
private static final Logger logger = LoggerFactory.getLogger(CustomerController.class);
@Autowired
private MollieClient mollieClient;
@Autowired
private PaymentService paymentService;
@PostMapping
public ResponseEntity<Map<String, Object>> createCustomer(@RequestBody CustomerRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Customer customer = mollieClient.createCustomer(request);
response.put("success", true);
response.put("customerId", customer.getId());
response.put("customer", customer);
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to create customer", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping("/{customerId}")
public ResponseEntity<Map<String, Object>> getCustomer(@PathVariable String customerId) {
Map<String, Object> response = new HashMap<>();
try {
Customer customer = mollieClient.getCustomer(customerId);
response.put("success", true);
response.put("customer", customer);
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to get customer: {}", customerId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@PutMapping("/{customerId}")
public ResponseEntity<Map<String, Object>> updateCustomer(
@PathVariable String customerId,
@RequestBody CustomerRequest request) {
Map<String, Object> response = new HashMap<>();
try {
Customer customer = mollieClient.updateCustomer(customerId, request);
response.put("success", true);
response.put("customer", customer);
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to update customer: {}", customerId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@DeleteMapping("/{customerId}")
public ResponseEntity<Map<String, Object>> deleteCustomer(@PathVariable String customerId) {
Map<String, Object> response = new HashMap<>();
try {
mollieClient.deleteCustomer(customerId);
response.put("success", true);
response.put("message", "Customer deleted successfully");
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to delete customer: {}", customerId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping
public ResponseEntity<Map<String, Object>> listCustomers(
@RequestParam(defaultValue = "10") int limit,
@RequestParam(required = false) String from) {
Map<String, Object> response = new HashMap<>();
try {
PaginatedResponse<Customer> customers = mollieClient.listCustomers(limit, from);
response.put("success", true);
response.put("customers", customers.getData());
response.put("count", customers.getCount());
response.put("hasNext", customers.getLinks() != null && customers.getLinks().getNext() != null);
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to list customers", e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
@GetMapping("/{customerId}/payments")
public ResponseEntity<Map<String, Object>> getCustomerPayments(
@PathVariable String customerId,
@RequestParam(defaultValue = "10") int limit) {
Map<String, Object> response = new HashMap<>();
try {
List<Payment> payments = paymentService.getCustomerPayments(customerId, limit);
response.put("success", true);
response.put("payments", payments);
response.put("count", payments.size());
return ResponseEntity.ok(response);
} catch (Exception e) {
logger.error("Failed to get customer payments: {}", customerId, e);
response.put("success", false);
response.put("error", e.getMessage());
return ResponseEntity.badRequest().body(response);
}
}
}

Application Properties

# Mollie Configuration
mollie.api.key=your_mollie_api_key_here
mollie.test.mode=true
# Application Configuration
app.webhook.base.url=https://yourdomain.com
app.redirect.base.url=https://yourdomain.com
# Server Configuration
server.port=8080
# Logging
logging.level.com.mollie=INFO

Usage Examples

Basic Usage

package com.mollie.examples;
import com.mollie.client.MollieClient;
import com.mollie.model.*;
import com.mollie.service.PaymentService;
import java.util.HashMap;
import java.util.Map;
public class MollieExamples {
public static void main(String[] args) {
// Initialize client
MollieClient client = new MollieClient("your_mollie_api_key", true);
PaymentService paymentService = new PaymentService(client, 
"https://yourdomain.com", "https://yourdomain.com");
try {
// Example 1: Create a simple payment
Map<String, Object> metadata = new HashMap<>();
metadata.put("orderId", "ORDER-123");
metadata.put("userId", "USER-456");
Payment payment = paymentService.createSimplePayment(
29.99, "EUR", "Order #ORDER-123", "ORDER-123", metadata);
System.out.println("Payment created: " + payment.getId());
System.out.println("Checkout URL: " + payment.getLinks().getCheckout());
// Example 2: Check payment status
String paymentId = payment.getId();
String status = paymentService.getPaymentStatus(paymentId);
System.out.println("Payment status: " + status);
// Example 3: Create a customer
Customer customer = paymentService.createCustomer(
"John Doe", "[email protected]", "en_US", new HashMap<>());
System.out.println("Customer created: " + customer.getId());
// Example 4: Create recurring payment for customer
// Note: You would need a mandate ID for recurring payments
// Payment recurringPayment = paymentService.createRecurringPayment(
//     customer.getId(), 29.99, "EUR", "Monthly subscription", "mandate_id", metadata);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Conclusion

This comprehensive Mollie Payments Java client provides:

  1. Complete API coverage for payments, refunds, and customers
  2. Payment processing for one-time and recurring payments
  3. Customer management for storing payment details
  4. Refund handling for processing returns
  5. Webhook integration for real-time payment updates
  6. Spring Boot integration for easy configuration

Key features:

  • Multiple payment methods support (iDEAL, credit card, PayPal, etc.)
  • Recurring payments for subscriptions
  • Comprehensive error handling with proper status codes
  • Type-safe models for all Mollie entities
  • Webhook processing for payment status updates
  • Customer management for improved user experience

This implementation enables Java applications to seamlessly integrate with Mollie's payment platform, providing robust payment processing capabilities for e-commerce applications, subscription services, and other payment-related use cases.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper