Stripe provides a complete payments platform for internet businesses with powerful APIs for payment processing, subscription management, and financial operations. This guide covers complete Stripe integration in Java applications.
Architecture Overview
Java Application â Stripe Java SDK â Stripe API â Payment Processors â (Payment Methods / Subscription Management)
Step 1: Dependencies Setup
Maven Dependencies
<!-- pom.xml --> <dependencies> <!-- Stripe Java SDK --> <dependency> <groupId>com.stripe</groupId> <artifactId>stripe-java</artifactId> <version>24.0.0</version> </dependency> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Validation --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> <!-- Configuration --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> </dependency> <!-- HTTP Client --> <dependency> <groupId>org.apache.httpcomponents.client5</groupId> <artifactId>httpclient5</artifactId> </dependency> <!-- Logging --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </dependency> </dependencies>
Step 2: Configuration Classes
Stripe Configuration
// src/main/java/com/company/stripe/config/StripeConfig.java
package com.company.stripe.config;
import com.stripe.Stripe;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
@Configuration
@ConfigurationProperties(prefix = "stripe")
@Data
@Slf4j
public class StripeConfig {
// API Keys
private String secretKey;
private String publishableKey;
private String webhookSecret;
// API Version
private String apiVersion = "2023-10-16";
// Timeout Configuration
private int connectTimeout = 30000;
private int readTimeout = 80000;
// Max Network Retries
private int maxNetworkRetries = 2;
// Currency Configuration
private String defaultCurrency = "usd";
// Business Information
private String companyName;
private String supportEmail;
private String supportPhone;
// Webhook Configuration
private boolean enableWebhooks = true;
private String successUrl;
private String cancelUrl;
@PostConstruct
public void initialize() {
// Set Stripe API key
Stripe.apiKey = this.secretKey;
// Configure Stripe global settings
Stripe.setConnectTimeout(connectTimeout);
Stripe.setReadTimeout(readTimeout);
Stripe.setMaxNetworkRetries(maxNetworkRetries);
log.info("Stripe SDK initialized successfully");
log.debug("Stripe API Version: {}, Currency: {}", apiVersion, defaultCurrency);
}
public void validateConfiguration() {
if (secretKey == null || secretKey.trim().isEmpty()) {
throw new IllegalStateException("Stripe secret key is not configured");
}
if (publishableKey == null || publishableKey.trim().isEmpty()) {
throw new IllegalStateException("Stripe publishable key is not configured");
}
}
}
Application Properties
# application.yml
stripe:
secret-key: ${STRIPE_SECRET_KEY:sk_test_...}
publishable-key: ${STRIPE_PUBLISHABLE_KEY:pk_test_...}
webhook-secret: ${STRIPE_WEBHOOK_SECRET:whsec_...}
api-version: "2023-10-16"
connect-timeout: 30000
read-timeout: 80000
max-network-retries: 2
default-currency: "usd"
company-name: "Your Company"
support-email: "[email protected]"
support-phone: "+1234567890"
enable-webhooks: true
success-url: "https://yourdomain.com/success"
cancel-url: "https://yourdomain.com/cancel"
server:
port: 8080
logging:
level:
com.company.stripe: DEBUG
com.stripe: INFO
Step 3: Core Payment Service
Payment Service Implementation
// src/main/java/com/company/stripe/service/PaymentService.java
package com.company.stripe.service;
import com.company.stripe.config.StripeConfig;
import com.stripe.exception.StripeException;
import com.stripe.model.*;
import com.stripe.net.RequestOptions;
import com.stripe.param.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.*;
@Service
@Slf4j
public class PaymentService {
private final StripeConfig stripeConfig;
public PaymentService(StripeConfig stripeConfig) {
this.stripeConfig = stripeConfig;
}
/**
* Create a payment intent for one-time payments
*/
public PaymentIntent createPaymentIntent(PaymentRequest request) {
try {
PaymentIntentCreateParams params = PaymentIntentCreateParams.builder()
.setAmount(convertToStripeAmount(request.getAmount()))
.setCurrency(request.getCurrency().toLowerCase())
.setCustomer(request.getCustomerId())
.setDescription(request.getDescription())
.setReceiptEmail(request.getReceiptEmail())
.setConfirmationMethod(PaymentIntentCreateParams.ConfirmationMethod.AUTOMATIC)
.setConfirm(true)
.setReturnUrl(stripeConfig.getSuccessUrl())
.setAutomaticPaymentMethods(
PaymentIntentCreateParams.AutomaticPaymentMethods.builder()
.setEnabled(true)
.build()
)
.putMetadata("order_id", request.getOrderId())
.putMetadata("user_id", request.getUserId())
.build();
PaymentIntent paymentIntent = PaymentIntent.create(params);
log.info("Payment intent created: {}", paymentIntent.getId());
return paymentIntent;
} catch (StripeException e) {
log.error("Failed to create payment intent", e);
throw new RuntimeException("Payment creation failed: " + e.getMessage(), e);
}
}
/**
* Confirm a payment intent
*/
public PaymentIntent confirmPaymentIntent(String paymentIntentId, String paymentMethodId) {
try {
PaymentIntentConfirmParams params = PaymentIntentConfirmParams.builder()
.setPaymentMethod(paymentMethodId)
.setReturnUrl(stripeConfig.getSuccessUrl())
.build();
PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
PaymentIntent confirmedIntent = paymentIntent.confirm(params);
log.info("Payment intent confirmed: {}", confirmedIntent.getId());
return confirmedIntent;
} catch (StripeException e) {
log.error("Failed to confirm payment intent: {}", paymentIntentId, e);
throw new RuntimeException("Payment confirmation failed: " + e.getMessage(), e);
}
}
/**
* Capture a payment intent (for authorized payments)
*/
public PaymentIntent capturePaymentIntent(String paymentIntentId) {
try {
PaymentIntentCaptureParams params = PaymentIntentCaptureParams.builder().build();
PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
PaymentIntent capturedIntent = paymentIntent.capture(params);
log.info("Payment intent captured: {}", capturedIntent.getId());
return capturedIntent;
} catch (StripeException e) {
log.error("Failed to capture payment intent: {}", paymentIntentId, e);
throw new RuntimeException("Payment capture failed: " + e.getMessage(), e);
}
}
/**
* Cancel a payment intent
*/
public PaymentIntent cancelPaymentIntent(String paymentIntentId) {
try {
PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
PaymentIntent canceledIntent = paymentIntent.cancel();
log.info("Payment intent canceled: {}", canceledIntent.getId());
return canceledIntent;
} catch (StripeException e) {
log.error("Failed to cancel payment intent: {}", paymentIntentId, e);
throw new RuntimeException("Payment cancellation failed: " + e.getMessage(), e);
}
}
/**
* Refund a payment
*/
public Refund createRefund(RefundRequest request) {
try {
RefundCreateParams params = RefundCreateParams.builder()
.setPaymentIntent(request.getPaymentIntentId())
.setAmount(convertToStripeAmount(request.getAmount()))
.setReason(convertRefundReason(request.getReason()))
.setMetadata(request.getMetadata())
.build();
Refund refund = Refund.create(params);
log.info("Refund created: {}", refund.getId());
return refund;
} catch (StripeException e) {
log.error("Failed to create refund for payment intent: {}", request.getPaymentIntentId(), e);
throw new RuntimeException("Refund creation failed: " + e.getMessage(), e);
}
}
/**
* Get payment intent by ID
*/
public PaymentIntent getPaymentIntent(String paymentIntentId) {
try {
PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
log.debug("Retrieved payment intent: {}", paymentIntentId);
return paymentIntent;
} catch (StripeException e) {
log.error("Failed to retrieve payment intent: {}", paymentIntentId, e);
throw new RuntimeException("Payment intent retrieval failed: " + e.getMessage(), e);
}
}
/**
* List payment intents with filtering
*/
public List<PaymentIntent> listPaymentIntents(PaymentListRequest request) {
try {
PaymentIntentListParams.Builder paramsBuilder = PaymentIntentListParams.builder()
.setLimit(request.getLimit());
if (request.getCustomerId() != null) {
paramsBuilder.setCustomer(request.getCustomerId());
}
if (request.getStatus() != null) {
paramsBuilder.addStatus(PaymentIntentListParams.Status.valueOf(request.getStatus().toUpperCase()));
}
PaymentIntentCollection paymentIntents = PaymentIntent.list(paramsBuilder.build());
return paymentIntents.getData();
} catch (StripeException e) {
log.error("Failed to list payment intents", e);
throw new RuntimeException("Payment intent listing failed: " + e.getMessage(), e);
}
}
/**
* Create a setup intent for saving payment methods
*/
public SetupIntent createSetupIntent(SetupIntentRequest request) {
try {
SetupIntentCreateParams params = SetupIntentCreateParams.builder()
.setCustomer(request.getCustomerId())
.setDescription(request.getDescription())
.setUsage(SetupIntentCreateParams.Usage.ON_SESSION)
.setAutomaticPaymentMethods(
SetupIntentCreateParams.AutomaticPaymentMethods.builder()
.setEnabled(true)
.build()
)
.putMetadata("user_id", request.getUserId())
.build();
SetupIntent setupIntent = SetupIntent.create(params);
log.info("Setup intent created: {}", setupIntent.getId());
return setupIntent;
} catch (StripeException e) {
log.error("Failed to create setup intent", e);
throw new RuntimeException("Setup intent creation failed: " + e.getMessage(), e);
}
}
/**
* Create a payment method
*/
public PaymentMethod createPaymentMethod(PaymentMethodRequest request) {
try {
PaymentMethodCreateParams.CardDetails cardDetails = PaymentMethodCreateParams.CardDetails.builder()
.setNumber(request.getCardNumber())
.setExpMonth(request.getExpMonth())
.setExpYear(request.getExpYear())
.setCvc(request.getCvc())
.build();
PaymentMethodCreateParams.BillingDetails billingDetails = PaymentMethodCreateParams.BillingDetails.builder()
.setName(request.getCardholderName())
.setEmail(request.getEmail())
.setPhone(request.getPhone())
.setAddress(
PaymentMethodCreateParams.BillingDetails.Address.builder()
.setLine1(request.getAddressLine1())
.setLine2(request.getAddressLine2())
.setCity(request.getCity())
.setState(request.getState())
.setPostalCode(request.getPostalCode())
.setCountry(request.getCountry())
.build()
)
.build();
PaymentMethodCreateParams params = PaymentMethodCreateParams.builder()
.setType(PaymentMethodCreateParams.Type.CARD)
.setCard(cardDetails)
.setBillingDetails(billingDetails)
.build();
PaymentMethod paymentMethod = PaymentMethod.create(params);
log.info("Payment method created: {}", paymentMethod.getId());
return paymentMethod;
} catch (StripeException e) {
log.error("Failed to create payment method", e);
throw new RuntimeException("Payment method creation failed: " + e.getMessage(), e);
}
}
/**
* Attach payment method to customer
*/
public PaymentMethod attachPaymentMethodToCustomer(String paymentMethodId, String customerId) {
try {
PaymentMethod paymentMethod = PaymentMethod.retrieve(paymentMethodId);
PaymentMethodAttachParams params = PaymentMethodAttachParams.builder()
.setCustomer(customerId)
.build();
PaymentMethod attachedMethod = paymentMethod.attach(params);
log.info("Payment method {} attached to customer {}", paymentMethodId, customerId);
return attachedMethod;
} catch (StripeException e) {
log.error("Failed to attach payment method to customer", e);
throw new RuntimeException("Payment method attachment failed: " + e.getMessage(), e);
}
}
/**
* Detach payment method from customer
*/
public PaymentMethod detachPaymentMethod(String paymentMethodId) {
try {
PaymentMethod paymentMethod = PaymentMethod.retrieve(paymentMethodId);
PaymentMethod detachedMethod = paymentMethod.detach();
log.info("Payment method detached: {}", paymentMethodId);
return detachedMethod;
} catch (StripeException e) {
log.error("Failed to detach payment method: {}", paymentMethodId, e);
throw new RuntimeException("Payment method detachment failed: " + e.getMessage(), e);
}
}
/**
* List customer's payment methods
*/
public List<PaymentMethod> listCustomerPaymentMethods(String customerId, String type) {
try {
PaymentMethodListParams params = PaymentMethodListParams.builder()
.setCustomer(customerId)
.setType(PaymentMethodListParams.Type.CARD)
.build();
PaymentMethodCollection paymentMethods = PaymentMethod.list(params);
return paymentMethods.getData();
} catch (StripeException e) {
log.error("Failed to list payment methods for customer: {}", customerId, e);
throw new RuntimeException("Payment method listing failed: " + e.getMessage(), e);
}
}
// Helper methods
private long convertToStripeAmount(BigDecimal amount) {
return amount.multiply(BigDecimal.valueOf(100)).longValue();
}
private BigDecimal convertFromStripeAmount(long stripeAmount) {
return BigDecimal.valueOf(stripeAmount).divide(BigDecimal.valueOf(100));
}
private RefundCreateParams.Reason convertRefundReason(RefundRequest.RefundReason reason) {
switch (reason) {
case DUPLICATE:
return RefundCreateParams.Reason.DUPLICATE;
case FRAUDULENT:
return RefundCreateParams.Reason.FRAUDULENT;
case REQUESTED_BY_CUSTOMER:
return RefundCreateParams.Reason.REQUESTED_BY_CUSTOMER;
default:
return RefundCreateParams.Reason.REQUESTED_BY_CUSTOMER;
}
}
// Request DTOs
@Data
public static class PaymentRequest {
private BigDecimal amount;
private String currency = "usd";
private String customerId;
private String description;
private String receiptEmail;
private String orderId;
private String userId;
private Map<String, String> metadata = new HashMap<>();
}
@Data
public static class RefundRequest {
private String paymentIntentId;
private BigDecimal amount;
private RefundReason reason;
private Map<String, String> metadata = new HashMap<>();
public enum RefundReason {
DUPLICATE, FRAUDULENT, REQUESTED_BY_CUSTOMER
}
}
@Data
public static class PaymentListRequest {
private Integer limit = 10;
private String customerId;
private String status; // requires_payment_method, requires_confirmation, requires_action, processing, requires_capture, canceled, succeeded
}
@Data
public static class SetupIntentRequest {
private String customerId;
private String description;
private String userId;
}
@Data
public static class PaymentMethodRequest {
// Card details
private String cardNumber;
private Long expMonth;
private Long expYear;
private String cvc;
private String cardholderName;
// Billing details
private String email;
private String phone;
private String addressLine1;
private String addressLine2;
private String city;
private String state;
private String postalCode;
private String country;
}
}
Step 4: Customer Management Service
Customer Service
// src/main/java/com/company/stripe/service/CustomerService.java
package com.company.stripe.service;
import com.stripe.exception.StripeException;
import com.stripe.model.Customer;
import com.stripe.model.PaymentMethod;
import com.stripe.model.PaymentMethodCollection;
import com.stripe.param.CustomerCreateParams;
import com.stripe.param.CustomerListParams;
import com.stripe.param.CustomerUpdateParams;
import com.stripe.param.PaymentMethodListParams;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
@Slf4j
public class CustomerService {
/**
* Create a new customer in Stripe
*/
public Customer createCustomer(CustomerCreateRequest request) {
try {
CustomerCreateParams.Builder paramsBuilder = CustomerCreateParams.builder()
.setEmail(request.getEmail())
.setName(request.getName())
.setPhone(request.getPhone())
.setDescription(request.getDescription());
// Add address if provided
if (request.getAddress() != null) {
CustomerCreateParams.Address address = CustomerCreateParams.Address.builder()
.setLine1(request.getAddress().getLine1())
.setLine2(request.getAddress().getLine2())
.setCity(request.getAddress().getCity())
.setState(request.getAddress().getState())
.setPostalCode(request.getAddress().getPostalCode())
.setCountry(request.getAddress().getCountry())
.build();
paramsBuilder.setAddress(address);
}
// Add metadata
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
Customer customer = Customer.create(paramsBuilder.build());
log.info("Customer created: {} - {}", customer.getId(), customer.getEmail());
return customer;
} catch (StripeException e) {
log.error("Failed to create customer: {}", request.getEmail(), e);
throw new RuntimeException("Customer creation failed: " + e.getMessage(), e);
}
}
/**
* Retrieve customer by ID
*/
public Customer getCustomer(String customerId) {
try {
Customer customer = Customer.retrieve(customerId);
log.debug("Retrieved customer: {}", customerId);
return customer;
} catch (StripeException e) {
log.error("Failed to retrieve customer: {}", customerId, e);
throw new RuntimeException("Customer retrieval failed: " + e.getMessage(), e);
}
}
/**
* Update customer information
*/
public Customer updateCustomer(String customerId, CustomerUpdateRequest request) {
try {
CustomerUpdateParams.Builder paramsBuilder = CustomerUpdateParams.builder();
if (request.getEmail() != null) {
paramsBuilder.setEmail(request.getEmail());
}
if (request.getName() != null) {
paramsBuilder.setName(request.getName());
}
if (request.getPhone() != null) {
paramsBuilder.setPhone(request.getPhone());
}
if (request.getDescription() != null) {
paramsBuilder.setDescription(request.getDescription());
}
// Update address if provided
if (request.getAddress() != null) {
CustomerUpdateParams.Address address = CustomerUpdateParams.Address.builder()
.setLine1(request.getAddress().getLine1())
.setLine2(request.getAddress().getLine2())
.setCity(request.getAddress().getCity())
.setState(request.getAddress().getState())
.setPostalCode(request.getAddress().getPostalCode())
.setCountry(request.getAddress().getCountry())
.build();
paramsBuilder.setAddress(address);
}
// Update metadata
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
Customer customer = Customer.retrieve(customerId);
Customer updatedCustomer = customer.update(paramsBuilder.build());
log.info("Customer updated: {}", customerId);
return updatedCustomer;
} catch (StripeException e) {
log.error("Failed to update customer: {}", customerId, e);
throw new RuntimeException("Customer update failed: " + e.getMessage(), e);
}
}
/**
* Delete a customer
*/
public Customer deleteCustomer(String customerId) {
try {
Customer customer = Customer.retrieve(customerId);
Customer deletedCustomer = customer.delete();
log.info("Customer deleted: {}", customerId);
return deletedCustomer;
} catch (StripeException e) {
log.error("Failed to delete customer: {}", customerId, e);
throw new RuntimeException("Customer deletion failed: " + e.getMessage(), e);
}
}
/**
* List customers with optional filtering
*/
public List<Customer> listCustomers(CustomerListRequest request) {
try {
CustomerListParams.Builder paramsBuilder = CustomerListParams.builder()
.setLimit(request.getLimit());
if (request.getEmail() != null) {
paramsBuilder.setEmail(request.getEmail());
}
return Customer.list(paramsBuilder.build()).getData();
} catch (StripeException e) {
log.error("Failed to list customers", e);
throw new RuntimeException("Customer listing failed: " + e.getMessage(), e);
}
}
/**
* Set customer's default payment method
*/
public Customer setDefaultPaymentMethod(String customerId, String paymentMethodId) {
try {
CustomerUpdateParams params = CustomerUpdateParams.builder()
.setInvoiceSettings(
CustomerUpdateParams.InvoiceSettings.builder()
.setDefaultPaymentMethod(paymentMethodId)
.build()
)
.build();
Customer customer = Customer.retrieve(customerId);
Customer updatedCustomer = customer.update(params);
log.info("Default payment method set for customer: {}", customerId);
return updatedCustomer;
} catch (StripeException e) {
log.error("Failed to set default payment method for customer: {}", customerId, e);
throw new RuntimeException("Default payment method setting failed: " + e.getMessage(), e);
}
}
/**
* Get customer's payment methods
*/
public List<PaymentMethod> getCustomerPaymentMethods(String customerId, String type) {
try {
PaymentMethodListParams params = PaymentMethodListParams.builder()
.setCustomer(customerId)
.setType(PaymentMethodListParams.Type.valueOf(type.toUpperCase()))
.build();
PaymentMethodCollection paymentMethods = PaymentMethod.list(params);
return paymentMethods.getData();
} catch (StripeException e) {
log.error("Failed to get payment methods for customer: {}", customerId, e);
throw new RuntimeException("Payment method retrieval failed: " + e.getMessage(), e);
}
}
// Request DTOs
@Data
public static class CustomerCreateRequest {
private String email;
private String name;
private String phone;
private String description;
private Address address;
private Map<String, String> metadata = new HashMap<>();
@Data
public static class Address {
private String line1;
private String line2;
private String city;
private String state;
private String postalCode;
private String country;
}
}
@Data
public static class CustomerUpdateRequest {
private String email;
private String name;
private String phone;
private String description;
private CustomerCreateRequest.Address address;
private Map<String, String> metadata = new HashMap<>();
}
@Data
public static class CustomerListRequest {
private Integer limit = 10;
private String email;
}
}
Step 5: Subscription Service
Subscription Management
// src/main/java/com/company/stripe/service/SubscriptionService.java
package com.company.stripe.service;
import com.stripe.exception.StripeException;
import com.stripe.model.*;
import com.stripe.param.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.*;
@Service
@Slf4j
public class SubscriptionService {
private final PriceService priceService;
public SubscriptionService(PriceService priceService) {
this.priceService = priceService;
}
/**
* Create a subscription for a customer
*/
public Subscription createSubscription(SubscriptionRequest request) {
try {
// Build subscription items
List<SubscriptionCreateParams.Item> items = new ArrayList<>();
for (SubscriptionItemRequest item : request.getItems()) {
SubscriptionCreateParams.Item subscriptionItem = SubscriptionCreateParams.Item.builder()
.setPrice(item.getPriceId())
.setQuantity(item.getQuantity())
.build();
items.add(subscriptionItem);
}
SubscriptionCreateParams.Builder paramsBuilder = SubscriptionCreateParams.builder()
.setCustomer(request.getCustomerId())
.addAllItem(items)
.setPaymentBehavior(SubscriptionCreateParams.PaymentBehavior.DEFAULT_INCOMPLETE)
.setPaymentSettings(
SubscriptionCreateParams.PaymentSettings.builder()
.setSaveDefaultPaymentMethod(SubscriptionCreateParams.PaymentSettings.SaveDefaultPaymentMethod.ON_SUBSCRIPTION)
.build()
)
.setExpand(Arrays.asList("latest_invoice.payment_intent"));
// Set trial period if provided
if (request.getTrialPeriodDays() != null) {
paramsBuilder.setTrialPeriodDays(request.getTrialPeriodDays());
}
// Set metadata
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
Subscription subscription = Subscription.create(paramsBuilder.build());
log.info("Subscription created: {} for customer {}", subscription.getId(), request.getCustomerId());
return subscription;
} catch (StripeException e) {
log.error("Failed to create subscription for customer: {}", request.getCustomerId(), e);
throw new RuntimeException("Subscription creation failed: " + e.getMessage(), e);
}
}
/**
* Retrieve subscription by ID
*/
public Subscription getSubscription(String subscriptionId) {
try {
Subscription subscription = Subscription.retrieve(subscriptionId);
log.debug("Retrieved subscription: {}", subscriptionId);
return subscription;
} catch (StripeException e) {
log.error("Failed to retrieve subscription: {}", subscriptionId, e);
throw new RuntimeException("Subscription retrieval failed: " + e.getMessage(), e);
}
}
/**
* Update subscription
*/
public Subscription updateSubscription(String subscriptionId, SubscriptionUpdateRequest request) {
try {
SubscriptionUpdateParams.Builder paramsBuilder = SubscriptionUpdateParams.builder();
// Update items if provided
if (request.getItems() != null && !request.getItems().isEmpty()) {
List<SubscriptionUpdateParams.Item> items = new ArrayList<>();
for (SubscriptionItemRequest item : request.getItems()) {
SubscriptionUpdateParams.Item subscriptionItem = SubscriptionUpdateParams.Item.builder()
.setId(item.getItemId()) // Existing item ID for updates
.setPrice(item.getPriceId())
.setQuantity(item.getQuantity())
.build();
items.add(subscriptionItem);
}
paramsBuilder.addAllItem(items);
}
// Update metadata
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
// Proration behavior
if (request.isProrate()) {
paramsBuilder.setProrationBehavior(SubscriptionUpdateParams.ProrationBehavior.CREATE_PRORATIONS);
}
Subscription subscription = Subscription.retrieve(subscriptionId);
Subscription updatedSubscription = subscription.update(paramsBuilder.build());
log.info("Subscription updated: {}", subscriptionId);
return updatedSubscription;
} catch (StripeException e) {
log.error("Failed to update subscription: {}", subscriptionId, e);
throw new RuntimeException("Subscription update failed: " + e.getMessage(), e);
}
}
/**
* Cancel subscription
*/
public Subscription cancelSubscription(String subscriptionId, CancelSubscriptionRequest request) {
try {
SubscriptionCancelParams.Builder paramsBuilder = SubscriptionCancelParams.builder();
if (request.isCancelAtPeriodEnd()) {
paramsBuilder.setCancelAtPeriodEnd(true);
}
Subscription subscription = Subscription.retrieve(subscriptionId);
Subscription canceledSubscription;
if (request.isCancelAtPeriodEnd()) {
canceledSubscription = subscription.update(
SubscriptionUpdateParams.builder()
.setCancelAtPeriodEnd(true)
.build()
);
} else {
canceledSubscription = subscription.cancel(paramsBuilder.build());
}
log.info("Subscription canceled: {}", subscriptionId);
return canceledSubscription;
} catch (StripeException e) {
log.error("Failed to cancel subscription: {}", subscriptionId, e);
throw new RuntimeException("Subscription cancellation failed: " + e.getMessage(), e);
}
}
/**
* Resume subscription
*/
public Subscription resumeSubscription(String subscriptionId) {
try {
SubscriptionUpdateParams params = SubscriptionUpdateParams.builder()
.setCancelAtPeriodEnd(false)
.build();
Subscription subscription = Subscription.retrieve(subscriptionId);
Subscription resumedSubscription = subscription.update(params);
log.info("Subscription resumed: {}", subscriptionId);
return resumedSubscription;
} catch (StripeException e) {
log.error("Failed to resume subscription: {}", subscriptionId, e);
throw new RuntimeException("Subscription resumption failed: " + e.getMessage(), e);
}
}
/**
* List customer's subscriptions
*/
public List<Subscription> listCustomerSubscriptions(String customerId, SubscriptionListRequest request) {
try {
SubscriptionListParams.Builder paramsBuilder = SubscriptionListParams.builder()
.setCustomer(customerId)
.setLimit(request.getLimit());
if (request.getStatus() != null) {
paramsBuilder.addStatus(SubscriptionListParams.Status.valueOf(request.getStatus().toUpperCase()));
}
SubscriptionCollection subscriptions = Subscription.list(paramsBuilder.build());
return subscriptions.getData();
} catch (StripeException e) {
log.error("Failed to list subscriptions for customer: {}", customerId, e);
throw new RuntimeException("Subscription listing failed: " + e.getMessage(), e);
}
}
/**
* Create invoice for subscription
*/
public Invoice createInvoice(String subscriptionId) {
try {
InvoiceCreateParams params = InvoiceCreateParams.builder()
.setSubscription(subscriptionId)
.build();
Invoice invoice = Invoice.create(params);
log.info("Invoice created: {} for subscription {}", invoice.getId(), subscriptionId);
return invoice;
} catch (StripeException e) {
log.error("Failed to create invoice for subscription: {}", subscriptionId, e);
throw new RuntimeException("Invoice creation failed: " + e.getMessage(), e);
}
}
/**
* Pay invoice immediately
*/
public Invoice payInvoice(String invoiceId) {
try {
Invoice invoice = Invoice.retrieve(invoiceId);
Invoice paidInvoice = invoice.pay();
log.info("Invoice paid: {}", invoiceId);
return paidInvoice;
} catch (StripeException e) {
log.error("Failed to pay invoice: {}", invoiceId, e);
throw new RuntimeException("Invoice payment failed: " + e.getMessage(), e);
}
}
// Request DTOs
@Data
public static class SubscriptionRequest {
private String customerId;
private List<SubscriptionItemRequest> items = new ArrayList<>();
private Integer trialPeriodDays;
private Map<String, String> metadata = new HashMap<>();
}
@Data
public static class SubscriptionItemRequest {
private String itemId; // For updates
private String priceId;
private Long quantity = 1L;
}
@Data
public static class SubscriptionUpdateRequest {
private List<SubscriptionItemRequest> items;
private Map<String, String> metadata = new HashMap<>();
private boolean prorate = true;
}
@Data
public static class CancelSubscriptionRequest {
private boolean cancelAtPeriodEnd = false;
}
@Data
public static class SubscriptionListRequest {
private Integer limit = 10;
private String status; // active, past_due, unpaid, canceled, incomplete, incomplete_expired, trialing, all
}
}
Step 6: Price and Product Service
Price Service
```java
// src/main/java/com/company/stripe/service/PriceService.java
package com.company.stripe.service;
import com.stripe.exception.StripeException;
import com.stripe.model.Price;
import com.stripe.model.Product;
import com.stripe.param.PriceCreateParams;
import com.stripe.param.PriceListParams;
import com.stripe.param.ProductCreateParams;
import com.stripe.param.ProductListParams;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
@Service
@Slf4j
public class PriceService {
/**
* Create a product
*/
public Product createProduct(ProductRequest request) {
try {
ProductCreateParams.Builder paramsBuilder = ProductCreateParams.builder()
.setName(request.getName())
.setDescription(request.getDescription())
.setActive(true);
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
Product product = Product.create(paramsBuilder.build());
log.info("Product created: {} - {}", product.getId(), product.getName());
return product;
} catch (StripeException e) {
log.error("Failed to create product: {}", request.getName(), e);
throw new RuntimeException("Product creation failed: " + e.getMessage(), e);
}
}
/**
* Create a price for a product
*/
public Price createPrice(PriceRequest request) {
try {
PriceCreateParams.Builder paramsBuilder = PriceCreateParams.builder()
.setProduct(request.getProductId())
.setCurrency(request.getCurrency().toLowerCase())
.setUnitAmount(convertToStripeAmount(request.getUnitAmount()));
// Set recurring if subscription
if (request.isRecurring()) {
PriceCreateParams.Recurring recurring = PriceCreateParams.Recurring.builder()
.setInterval(PriceCreateParams.Recurring.Interval.valueOf(
request.getInterval().toUpperCase()))
.build();
paramsBuilder.setRecurring(recurring);
}
if (request.getMetadata() != null) {
paramsBuilder.putAllMetadata(request.getMetadata());
}
Price price = Price.create(paramsBuilder.build());
log.info("Price created: {} for product {}", price.getId(), request.getProductId());
return price;
} catch (StripeException e) {
log.error("Failed to create price for product: {}", request.getProductId(), e);
throw new RuntimeException("Price creation failed: " + e.getMessage(), e);
}
}
/**
* List all active products
*/
public List<Product> listProducts(ProductListRequest request) {
try {
ProductListParams.Builder paramsBuilder = ProductListParams.builder()
.setActive(true)
.setLimit(request.getLimit());
return Product.list(paramsBuilder.build()).getData();
} catch (StripeException e) {
log.error("Failed to list products", e);
throw new RuntimeException("Product