DEV Community: Munaf Badarpura

Integrating Stripe Payments in Spring Boot: Step-by-Step Beginner’s Guide (2025)

Munaf Badarpura — Fri, 17 Oct 2025 11:07:50 +0000

Integrating payment processing into your Spring Boot application can seem daunting, but with Stripe's robust API and Spring Boot's flexibility, it’s a manageable task. In this guide, we'll walk through the process of integrating Stripe payments into a Spring Boot application, focusing on a booking system example. We'll cover setting up Stripe, initiating a payment session, handling webhooks, and confirming payments.

Prerequisites

A Stripe account with API keys (secret key and webhook secret).
A Spring Boot project set up with dependencies like spring-boot-starter-web and stripe-java.
Basic knowledge of Spring Boot, REST APIs, and Java.
Add the Stripe Java library to your pom.xml:

<dependency>
    <groupId>com.stripe</groupId>
    <artifactId>stripe-java</artifactId>
    <version>25.6.0</version>
</dependency>

Step 1: Configuring Stripe in Spring Boot

To use Stripe's API, you need to set up your Stripe secret key in the application. This key authenticates your API requests.

In your application.properties or application.yml, add:

stripe.secret.key=sk_test_your_stripe_secret_key
stripe.webhook.secret=whsec_your_webhook_secret

Create a configuration class to initialize the Stripe API with the secret key:

import com.stripe.Stripe;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StripeConfig {

    @Value("${stripe.secret.key}")
    private String stripeSecretKey;

    @PostConstruct
    public void init() {
        Stripe.apiKey = stripeSecretKey; // Set up Stripe API key
    }
}

This ensures the Stripe API key is set when the application starts.

Step 2: Initiating a Payment Session

To process payments, you’ll create a Stripe Checkout Session, which redirects users to a Stripe-hosted payment page. Below is an example of initiating a payment for a booking.

Controller for Initiating Payment

Create a REST endpoint to initiate a payment for a booking:

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/bookings")
public class BookingController {

    private final BookingService bookingService;

    public BookingController(BookingService bookingService) {
        this.bookingService = bookingService;
    }

    @PostMapping("/{bookingId}/payments")
    public ResponseEntity<BookingPaymentInitResponseDto> initiateBookingPayment(@PathVariable Long bookingId) {
        BookingPaymentInitResponseDto response = new BookingPaymentInitResponseDto(bookingService.initiateBookingPayment(bookingId));
        return new ResponseEntity<>(response, HttpStatus.OK);
    }
}

The BookingPaymentInitResponseDto is a simple data transfer object (DTO) to return the Stripe session URL:

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BookingPaymentInitResponseDto {
    private String sessionUrl;
}

Service Logic for Payment Initiation

In the service layer, validate the booking, check user authorization, and create a Stripe Checkout Session:

import com.stripe.exception.StripeException;
import com.stripe.model.Customer;
import com.stripe.model.Session;
import com.stripe.param.CustomerCreateParams;
import com.stripe.param.SessionCreateParams;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Slf4j
public class BookingService {

    private final BookingRepository bookingRepository;
    private final InventoryRepository inventoryRepository;
    private final String frontendUrl;

    public BookingService(BookingRepository bookingRepository, InventoryRepository inventoryRepository, @Value("${frontend.url}") String frontendUrl) {
        this.bookingRepository = bookingRepository;
        this.inventoryRepository = inventoryRepository;
        this.frontendUrl = frontendUrl;
    }

    @Transactional(noRollbackFor = BookingExpiredException.class)
    public String initiateBookingPayment(Long bookingId) {
        Booking booking = bookingRepository.findById(bookingId)
                .orElseThrow(() -> new ResourceNotFoundException("Booking Not Found With Id: " + bookingId));

        User user = getCurrentUser(); // Assume this retrieves the authenticated user

        if (!user.equals(booking.getUser())) {
            throw new UnAuthorisedException("Booking Does Not Belong To This User With Id: " + user.getId());
        }

        if (hasBookingExpired(booking.getCreatedAt())) {
            inventoryRepository.expireBooking(booking.getRoom().getId(),
                    booking.getCheckInDate(),
                    booking.getCheckOutDate(),
                    booking.getNumberOfRooms());
            booking.setBookingStatus(BookingStatus.EXPIRED);
            bookingRepository.save(booking);
            throw new BookingExpiredException("Booking Has Been Already Expired");
        }

        String sessionUrl = getCheckoutSession(booking, frontendUrl + "/payment/success", frontendUrl + "/payment/failure");
        booking.setBookingStatus(BookingStatus.PAYMENT_PENDING);
        bookingRepository.save(booking);

        return sessionUrl;
    }

    public String getCheckoutSession(Booking booking, String successUrl, String failureUrl) {
        log.info("Creating session for booking with Id: {}", booking.getId());
        User user = getCurrentUser();

        try {
            CustomerCreateParams customerParams = CustomerCreateParams.builder()
                    .setName(user.getName())
                    .setEmail(user.getEmail())
                    .build();
            Customer customer = Customer.create(customerParams);

            SessionCreateParams sessionParams = SessionCreateParams.builder()
                    .setMode(SessionCreateParams.Mode.PAYMENT)
                    .setBillingAddressCollection(SessionCreateParams.BillingAddressCollection.REQUIRED)
                    .setCustomer(customer.getId())
                    .setSuccessUrl(successUrl)
                    .setCancelUrl(failureUrl)
                    .addLineItem(
                            SessionCreateParams.LineItem.builder()
                                    .setQuantity(Long.valueOf(booking.getNumberOfRooms()))
                                    .setPriceData(
                                            SessionCreateParams.LineItem.PriceData.builder()
                                                    .setCurrency("inr")
                                                    .setUnitAmount(booking.getAmount().multiply(BigDecimal.valueOf(100)).longValue())
                                                    .setProductData(
                                                            SessionCreateParams.LineItem.PriceData.ProductData.builder()
                                                                    .setName(booking.getHotel().getName() + " : " + booking.getRoom().getType())
                                                                    .setDescription("Booking ID: " + booking.getId())
                                                                    .build()
                                                    )
                                                    .build()
                                    )
                                    .build()
                    )
                    .build();

            Session session = Session.create(sessionParams);
            booking.setPaymentSessionId(session.getId());
            bookingRepository.save(booking);

            log.info("Session created successfully for booking with Id: {}", booking.getId());
            return session.getUrl();
        } catch (StripeException e) {
            throw new RuntimeException("Failed to create Stripe session", e);
        }
    }
}

This code:

Validates the booking and user.
Checks if the booking has expired.
Creates a Stripe customer and a checkout session with details like the hotel name, room type, and amount (in INR, multiplied by 100 for Stripe’s cent-based system).
Updates the booking status to PAYMENT_PENDING and saves the session ID.

Step 3: Handling Stripe Webhooks

Stripe uses webhooks to notify your application of payment events, such as a completed checkout session. Set up a webhook endpoint to handle these events.

Webhook Controller

import com.stripe.exception.SignatureVerificationException;
import com.stripe.model.Event;
import com.stripe.net.Webhook;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/webhook")
public class StripeWebhookController {

    private final BookingService bookingService;
    private final String endpointSecret;

    public StripeWebhookController(BookingService bookingService, @Value("${stripe.webhook.secret}") String endpointSecret) {
        this.bookingService = bookingService;
        this.endpointSecret = endpointSecret;
    }

    @PostMapping("/payment")
    public ResponseEntity<Void> capturePayments(@RequestBody String payload, @RequestHeader("Stripe-Signature") String sigHeader) {
        try {
            Event event = Webhook.constructEvent(payload, sigHeader, endpointSecret);
            bookingService.capturePayment(event);
            return ResponseEntity.noContent().build();
        } catch (SignatureVerificationException e) {
            throw new RuntimeException("Invalid webhook signature", e);
        }
    }
}

Webhook Handling Logic

Add the webhook handling logic to the BookingService:

import com.stripe.model.Session;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Slf4j
public class BookingService {

    // Other methods as above...

    @Transactional
    public void capturePayment(Event event) {
        if ("checkout.session.completed".equals(event.getType())) {
            Session session = (Session) event.getDataObjectDeserializer().getObject().orElse(null);
            if (session == null) return;

            String sessionId = session.getId();
            Booking booking = bookingRepository.findByPaymentSessionId(sessionId)
                    .orElseThrow(() -> new ResourceNotFoundException("Booking not found for session Id: " + sessionId));

            booking.setBookingStatus(BookingStatus.CONFIRMED);
            bookingRepository.save(booking);

            List<Inventory> lockReservedInventory = inventoryRepository.findAndLockReservedInventory(
                    booking.getRoom().getId(),
                    booking.getCheckInDate(),
                    booking.getCheckOutDate(),
                    booking.getNumberOfRooms());

            inventoryRepository.confirmBooking(
                    booking.getRoom().getId(),
                    booking.getCheckInDate(),
                    booking.getCheckOutDate(),
                    booking.getNumberOfRooms());

            log.info("Successfully confirmed the booking for Booking Id: {}", booking.getId());
        } else {
            log.warn("Unhandled event type: {}", event.getType());
        }
    }
}

This code:

Verifies the webhook event using the Stripe webhook secret.
Processes the checkout.session.completed event to confirm the booking.
Updates the booking status to CONFIRMED and adjusts inventory (e.g., decreases reserved rooms and increases booked rooms).

Step 4: Testing the Integration

Set Up Webhooks Locally: Use a tool like ngrok to expose your local server to Stripe’s webhook events. Configure the webhook URL in the Stripe Dashboard (e.g., https://your-ngrok-url/webhook/payment).
Test Payment Flow:
- Create a booking and initiate a payment via the /api/bookings/{bookingId}/payments endpoint.
- Use Stripe’s test card (e.g., 4242 4242 4242 4242) to complete the payment.
- Verify that the webhook updates the booking status to CONFIRMED.
Handle Errors: Test edge cases like expired bookings or invalid payments to ensure proper exception handling.

Read complete blog here : https://www.codingshuttle.com/blogs/integrating-stripe-payments-in-spring-boot-step-by-step-beginner-s-guide-2025/

Spring Boot File Upload with Multipart Support: Complete Guide

Munaf Badarpura — Fri, 17 Oct 2025 11:07:03 +0000

File uploading is a key feature in many web applications, whether for user profile images, document uploads, or media files. Spring Boot simplifies this process with its robust support for handling multipart file uploads.

In this blog, we'll explore how to implement file uploads in a Spring Boot application using multipart support, including a REST controller, service layer, and database integration. We'll also discuss different file upload approaches and why multipart is often the preferred method.

Different Ways of File Uploading

There are several approaches to handle file uploads in Spring Boot, each suited for specific use cases:

Multipart Form Data:
- Uses the MultipartFile interface to handle files sent via HTTP POST requests.
- Ideal for web forms where users upload files alongside other form data (e.g., name, description).
- Example: Uploading a profile picture with metadata like username and file type.
Base64 Encoded Files:
- Files are encoded as Base64 strings and sent in the request body (e.g., as JSON).
- Useful for APIs where files are embedded in payloads, but increases payload size due to encoding.
- Drawback: Less efficient for large files due to encoding overhead.
Direct Stream Upload:
- Files are streamed directly to a server or storage service (e.g., Amazon S3) without temporary storage.
- Best for large files or high-performance applications.
- Requires integration with external storage services.
Servlet-based Upload:
- Uses HttpServletRequest to access raw input streams for file data.
- More manual and less abstracted than MultipartFile, but offers fine-grained control.
- Suitable for custom or legacy applications.

In this blog, we'll focus on the multipart form data approach due to its simplicity and widespread use in web applications.

Why Use Multipart?

Multipart form data is the go-to choice for file uploads in Spring Boot for several reasons:

Efficient File Handling: Spring Boot's MultipartFile interface abstracts the complexity of handling file streams, making it easy to process uploaded files.
Support for Metadata: Multipart requests allow sending files alongside additional data (e.g., file name, type, or description) in a single request.
Browser Compatibility: HTML forms natively support multipart form data, making it ideal for web applications with file upload forms.
Scalability: Multipart uploads can be integrated with cloud storage services like Amazon S3, allowing scalable file storage.
Built-in Support: Spring Boot provides out-of-the-box support for multipart uploads via annotations like @ModelAttribute and configuration properties for file size limits.

Implementation: File Upload with Multipart Support

1. Add the following dependencies in your pom.xml :

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. Create the File Upload Request Model :

@Data
public class FileUploadRequest {
    private String name;
    private String type;
    private MultipartFile image;
}

3. Define the Entity for File Metadata :

@Entity
@Data
public class FileUploading {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String type;
    private String imageURL;
}

4. Implement the File Upload Service :

@Service
public class FileUploadingService {
    private final FileUploadingRepository fileUploadingRepository;

    public FileUploadingService(FileUploadingRepository fileUploadingRepository) {
        this.fileUploadingRepository = fileUploadingRepository;
    }

    public FileUploading uploadImage(FileUploadRequest fileUploadRequest) {
        MultipartFile image = fileUploadRequest.getImage();
        String fileName = image.getOriginalFilename();
        // Simulate S3 upload (replace with actual S3 logic)
        String imageUrl = "https://amazon/images/url/" + fileName;
        FileUploading fileUploading = new FileUploading();
        fileUploading.setName(fileUploadRequest.getName());
        fileUploading.setType(fileUploadRequest.getType());
        fileUploading.setImageURL(imageUrl);
        return fileUploadingRepository.save(fileUploading);
    }
}

For real S3 integration, use the AWS SDK:

AmazonS3 s3Client = AmazonS3ClientBuilder.standard().build();
s3Client.putObject("your-bucket-name", fileName, image.getInputStream(), new ObjectMetadata());
String imageUrl = s3Client.getUrl("your-bucket-name", fileName).toString();

5. Create the REST Controller ****:

@RestController
@RequestMapping("/file-uploading")
public class FileUploadingController {
    private final FileUploadingService fileUploadingService;

    public FileUploadingController(FileUploadingService fileUploadingService) {
        this.fileUploadingService = fileUploadingService;
    }

    @PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public FileUploading uploadImage(@ModelAttribute FileUploadRequest fileUploadRequest) {
        return fileUploadingService.uploadImage(fileUploadRequest);
    }
}

6. Configure File Upload Limits :

spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

Read complete blog here : https://www.codingshuttle.com/blogs/spring-boot-caching-with-redis-boost-performance-with-fast-operations-2025/

Spring Boot Caching with Redis: Boost Performance with Fast Operations (2025)

Munaf Badarpura — Fri, 17 Oct 2025 11:06:25 +0000

Caching is a powerful technique to enhance the performance of your Spring Boot application by storing frequently accessed data in memory for rapid retrieval. Redis, a high-performance in-memory data store, is an excellent choice for caching due to its speed and scalability.

In this blog, we’ll explore how to integrate Redis with Spring Boot to implement caching, covering setup, implementation, and key annotations with practical CRUD examples.

Read complete blog here : https://www.codingshuttle.com/blogs/spring-boot-caching-with-redis-boost-performance-with-fast-operations-2025-1/

Java Executor Framework Tutorial: Simplifying Multithreading with ExecutorService

Munaf Badarpura — Tue, 14 Oct 2025 08:20:08 +0000

In Java, Managing threads manually can be a complex task because it involves thread creation, synchronization and also thread lifecycle management. to simplifying the Java Executor Framework, part of the java.util.concurrent package, provides a robust solution to handle these complexities with ease.

It abstracts thread management and allows developers to focus on task execution. So in this blog we explores the Executor Framework, its components, and practical usage with examples.

What is the Executor Framework?

The Executor Framework is a high-level API designed to manage threads and execute tasks asynchronously. Instead of directly creating and managing Thread objects, you can use the framework to submit tasks and let it handle the underlying thread pool. At its core, the framework revolves around the Executor interface, with ExecutorService extending it to offer advanced features.

Key Components

Executor: The base interface defining a simple task execution mechanism.
ExecutorService: An extension of Executor that provides methods to manage task submission, shutdown, and thread pools.
ThreadPoolExecutor: A concrete implementation that manages a pool of threads, configurable with core and maximum pool sizes.
ScheduledExecutorService: A specialized service for scheduling tasks to run after a delay or at fixed intervals.
ForkJoinPool: Optimized for tasks that can be recursively split into smaller subtasks.

Why Use the Executor Framework?

Simplified Thread Management: No need to manually create or destroy threads.
Thread Reuse: Reduces overhead by reusing threads from a pool.
Flexible Task Submission: Supports Runnable and Callable tasks with Future results.
Controlled Shutdown: Offers graceful termination with shutdown() and shutdownNow().

How It Works

The Executor Framework uses a thread pool to manage tasks. Submitters send tasks to the ExecutorService, which queues them in a task queue (e.g., ArrayBlockingQueue or LinkedBlockingQueue). A pool of threads picks tasks from the queue and executes them. This process is illustrated by the diagram showing task submission, queuing, and execution by threads.

Configuring a ThreadPoolExecutor

A ThreadPoolExecutor can be customized with parameters:

Core Pool Size: Minimum number of threads kept alive (e.g., 4).
Maximum Pool Size: Maximum number of threads that can be created (e.g., 7).
Keep Alive Time: Idle time after which extra threads are terminated (e.g., 2 seconds).
Task Queue: A queue to hold pending tasks (e.g., LinkedBlockingQueue).

Example configuration:

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    4,      // corePoolSize
    7,      // maximumPoolSize
    2,      // keepAliveTime (seconds)
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>()
);

Submitting Tasks

Tasks can be submitted in two main ways:

execute(Runnable): Fire-and-forget execution, suitable for tasks without return values.
submit(Runnable/Callable): Returns a Future object to track task completion or retrieve results.

Example: Submitting a Runnable Task

threadPoolExecutor.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("Task 1(4Seconds) Started by Thread Name : " + Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Task 1(4Seconds) Ended by Thread Name : " + Thread.currentThread().getName());
    }
});

This code submits a task that sleeps for 4 seconds, printing the thread name before and after.

Shutting Down the Executor

To terminate the thread pool gracefully:

shutdown(): Initiates a shutdown, completing ongoing tasks but not accepting new ones.
shutdownNow(): Attempts to stop all tasks immediately, interrupting active threads.

Example:

threadPoolExecutor.shutdown();

Read complete blog here : https://www.codingshuttle.com/blogs/java-executor-framework-tutorial-simplifying-multithreading-with-executor-service/

Spring Boot @Scheduled Tutorial: Building Scheduled Tasks with TaskScheduler

Munaf Badarpura — Tue, 14 Oct 2025 07:22:30 +0000

Task scheduling is the process of executing methods or tasks at specified times or intervals, either once or repeatedly, without manual intervention. Spring Boot simplifies this with the @Scheduled annotation and the TaskScheduler.

This enabling developers to automate tasks like logging, notifications, and data processing. This blog explores how to implement scheduled tasks in Spring Boot, including configuration, use cases, and best practices.

What is Task Scheduling in Spring Boot?

Spring Boot provides built-in support for scheduling through the @Scheduled annotation, which integrates with the TaskScheduler interface. By default, it uses a ScheduledExecutorService under the hood, leveraging a thread pool for task execution. This allows for efficient management of recurring or delayed tasks without manual thread handling.

Common Use Cases

Logging user activity in a separate thread.
Sending emails or SMS notifications asynchronously after user actions.
Processing multiple image uploads, database queries, or API calls in parallel.
Cleaning up expired database records.
Archiving logs.
Fetching data from external APIs regularly.
Performing regular health checks on external systems or services.

Setting Up Scheduled Tasks

Steps to Implement

Enable Scheduling: Add @EnableScheduling to the main application class to activate Spring’s scheduling support.
Annotate the Method: Use @Scheduled on the method you want to schedule.
Method Requirements: The method must be void and take no arguments.

Example Configuration

import org.springframework.boot.SpringApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

@EnableScheduling
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Component
class ScheduledTasks {
    @Scheduled(fixedRate = 5000) // Runs every 5 seconds
    public void reportCurrentTime() {
        System.out.println("Current time: " + new java.util.Date());
    }
}

How @Scheduled Works

When a method is annotated with @Scheduled, Spring:

Registers it as a scheduled task.
Delegates execution to a TaskScheduler implementation.
Uses a thread pool (defaulting to ScheduledExecutorService) for concurrent task execution.
By default, employs a single-threaded executor, running tasks sequentially.

Customizing for Concurrency

By default, tasks run sequentially. To enable parallel execution, configure a custom TaskScheduler with a thread pool:

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Configuration
public class TaskSchedulingConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5); // Allows 5 tasks to run concurrently
        scheduler.setThreadNamePrefix("CustomTaskScheduler-"); // Optional: Custom thread name
        scheduler.initialize(); // Initialize the scheduler
        return scheduler;
    }
}

Asynchronous Task Scheduling

Blocking Behavior

By default, @Scheduled tasks are blocking. For example, if a task takes 5 seconds and is scheduled every 2 seconds, it will only rerun after the previous execution completes. This can lead to delays.

Enabling Async Execution

To avoid blocking, use the @Async annotation:

Add @EnableAsync to the main application class.
Annotate the scheduled method with @Async.

Example:

import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@EnableAsync
@Component
class ScheduledTasks {
    @Scheduled(fixedRate = 2000) // Every 2 seconds
    @Async
    public void asyncTask() {
        try {
            Thread.sleep(5000); // Simulates a 5-second task
            System.out.println("Async task completed at: " + new java.util.Date());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Note: @Async is ignored if the method is called within the same class due to Spring’s proxy mechanism. Move the method to a separate class or use a proxy instance.

Benefits of @async

Frees the main thread for other operations by offloading time-consuming tasks to a new thread.
Improves responsiveness in applications with heavy scheduled workloads.

Read complete blog here : https://www.codingshuttle.com/blogs/spring-boot-scheduled-tutorial-building-scheduled-tasks-with-task-scheduler/

Date and Time API in Java 8+: Best Practices & Common Mistakes

Munaf Badarpura — Tue, 14 Oct 2025 07:21:59 +0000

The introduction of the Java 8 Date and Time API (java.time package) marked a significant improvement over the legacy java.util.Date and java.util.Calendar classes. These are Designed to be immutable, thread-safe, and intuitive, this API is the go-to choice for handling dates, times, and durations in modern Java applications.

In this blog we explore explores how to use the API effectively and highlights mistakes to avoid. So let’s get started.

Why Use the Java 8+ Date and Time API?

The java.time API addresses the shortcomings of older classes, offering:

Immutability to prevent unintended modifications.
Thread-safety for concurrent applications.
Clear separation of concerns (e.g., date-only, time-only, or combined types).
Support for time zones and internationalization.

Key classes include LocalDate, LocalTime, LocalDateTime, ZonedDateTime, and Duration.

Best Practices

1. Prefer Specific Types Over General Ones

Use LocalDate for dates without time, LocalTime for times without dates, and LocalDateTime for combined date-time values. Avoid LocalDateTime when time zones are relevant; use ZonedDateTime or OffsetDateTime instead.

LocalDate date = LocalDate.of(2025, 9, 8); // 2025-09-08
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Kolkata")); // 2025-09-08T10:32+05:30[Asia/Kolkata]

2. Handle Time Zones Explicitly

Always specify time zones when dealing with global applications to avoid ambiguity. Use ZoneId and ZoneOffset for precision.

ZonedDateTime utcTime = ZonedDateTime.now(ZoneOffset.UTC);
System.out.println(utcTime); // e.g., 2025-09-08T05:02+00:00[UTC]

3. Use Immutability to Your Advantage

Since java.time objects are immutable, chain methods safely without side effects.

LocalDate nextWeek = LocalDate.now().plusWeeks(1);

4. Parse and Format with Standard Methods

Use DateTimeFormatter for consistent parsing and formatting instead of manual string manipulation.

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
String formattedDate = LocalDateTime.now().format(formatter); // e.g., 2025-09-08 10:32
LocalDateTime parsedDate = LocalDateTime.parse("2025-09-08 10:32", formatter);

5. Manage Durations and Periods

Use Duration for time-based amounts (e.g., hours, minutes) and Period for date-based amounts (e.g., years, months).

Duration duration = Duration.ofHours(2);
Period period = Period.ofMonths(3);

6. Avoid Legacy Classes

Minimize use of Date and Calendar. Convert them to java.time types when necessary using Instant or ZonedDateTime.

Instant instant = new Date().toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());

Common Mistakes to Avoid

1. Ignoring Time Zones

Failing to account for time zones can lead to incorrect date-time calculations, especially in distributed systems.

Mistake:

LocalDateTime now = LocalDateTime.now(); // No time zone, assumes system default

Fix:

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("Asia/Kolkata"))

2. Mutating Objects

Attempting to modify java.time objects (which are immutable) can cause confusion.

Mistake:

LocalDate date = LocalDate.now();
date = date.plusDays(1); // Correct, but some expect mutation

Fix: Understand immutability and assign the result to a new variable.

3. Overusing `now()` Without Context

Calling LocalDateTime.now() without a ZoneId relies on the system’s default, which may change.

Mistake:

LocalDateTime now = LocalDateTime.now(); // Depends on system time zone

Fix:

LocalDateTime now = LocalDateTime.now(Clock.systemUTC());

4. Manual String Parsing

Parsing dates with SimpleDateFormat from the legacy API is error-prone and not thread-safe.

Mistake:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse("2025-09-08"); // Not thread-safe

Fix:

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date = LocalDate.parse("2025-09-08", formatter);

5. Misusing `Instant` for Local Operations

Instant represents a point on the timeline in UTC, which may not suit local date-time needs.

Mistake:

Instant instant = Instant.now();
System.out.println(instant.plusDays(1)); // UTC-based, no local adjustment

Fix:

ZonedDateTime zdt = ZonedDateTime.now().plusDays(1); // Zone-aware

Read complete blog here : https://www.codingshuttle.com/blogs/date-and-time-api-in-java-8-best-practices-and-common-mistakes/

Java Records: A Modern Way to Write Immutable Data Classes

Munaf Badarpura — Mon, 13 Oct 2025 10:19:52 +0000

In the evolving world of Java, managing data efficiently and ensuring immutability are key concerns for developers. and to solve this problem Java Introduced records. A Java records offer a modern approach to creating immutable data classes.

Unlike traditional Java classes, records are designed specifically for holding data, reducing boilerplate code and enhancing readability. And in this blog we dives into Java records, their benefits, and how they revolutionize the creation of immutable data structures.

What Are Java Records?

A record is a special type of class in Java that automatically provides a concise syntax for declaring immutable data carriers. It generates constructors, getters, equals(), hashCode(), and toString() methods based on the components defined in its declaration. This eliminates the need to write repetitive code for simple data-holding classes.

Syntax Example

public record Person(String name, int age) {}

This single line creates a Person record with name and age as components, automatically providing:

A canonical constructor.
Getter methods (name() and age()).
Implementations of equals(), hashCode(), and toString().

Why Use Records?

Immutability: Records are inherently immutable, ensuring data cannot be altered after creation, which is ideal for value-based objects.
Reduced Boilerplate: No need to manually write getters, setters, or equality methods.
Clarity: The intent of the class as a data holder is immediately clear, improving code maintainability.
Performance: Compiled records are optimized for memory and speed compared to traditional classes with similar functionality.

Key Features

Compact Constructors: Allows validation or initialization logic within a concise constructor.

public record Person(String name, int age) {
    public Person {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
        if (name == null || name.isBlank()) throw new IllegalArgumentException("Name cannot be empty");
    }
}

Component Access: Access components using method names that match the field names (e.g., person.name()).
No Setter Methods: Prevents modification, enforcing immutability.
Custom Methods: You can add business logic or additional methods as needed.

public record Person(String name, int age) {
    public boolean isAdult() {
        return age >= 18;
    }
}

Creating and Using Records

Instantiation

Person person = new Person("Alice", 25);
System.out.println(person); // Output: Person[name=Alice, age=25]
System.out.println(person.isAdult()); // Output: true

Immutability in Action

Once created, the record's state cannot change:

person.name("Bob"); // Compilation error: no setter exists

Comparing with Traditional Classes

Traditional immutable classes require more code:

public class PersonOld {
    private final String name;
    private final int age;

    public PersonOld(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    @Override public boolean equals(Object o) { ... }
    @Override public int hashCode() { ... }
    @Override public String toString() { ... }
}

With records, the same functionality is achieved with less effort and potential for human error.

Read complete blog here : https://www.codingshuttle.com/blogs/java-records-a-modern-way-to-write-immutable-data-classes/

Mastering Optional in Java: Avoid NullPointerExceptions with Best Practices

Munaf Badarpura — Mon, 13 Oct 2025 10:15:56 +0000

NullPointerExceptions are a common headache for Java developers. They often arise from unhandled null references, and when they occur they lead to runtime crashes. As we know, this can be very frustrating. But to avoid this frustration, Java introduced the Optional class in Java 8.

The Optional class offers a powerful way to handle null values gracefully. It reduces the risk of NullPointerExceptions and helps make code more robust. In this blog, we'll explore how to master Optional in Java with practical examples to demonstrate its power.

What is NullPointerException?

A NullPointerException (NPE) happens in Java when your code tries to use something that doesn’t exist in other words, when a variable points to null instead of a real object.

Example:

String name = null;
System.out.println(name.length()); // Boom! NullPointerException

Here, name has no value (it’s null), so when we ask for length(), Java throws a NullPointerException.

What is Optional?

Optional<T> is a container object that may or may not contain a non-null value. It encourages explicit handling of cases where a value might be absent, making your code more expressive and safer. Instead of returning null, methods can return an Optional to indicate that a value might not exist.

Think of Optional as a box: it either contains something (a value) or is empty. By forcing developers to handle both cases, Optional prevents accidental NPEs.

Why Use Optional?

Avoid NullPointerExceptions: Optional forces you to think about the absence of a value, reducing the chance of dereferencing null.
Cleaner Code: It provides a fluent API for handling missing values, reducing boilerplate if (value != null) checks.
Better Intent: Using Optional signals to other developers that a method might not return a value, improving code readability.

Creating an Optional

You can create an Optional in several ways:

Empty Optional: Represents the absence of a value.

Optional<String> empty = Optional.empty();

Optional with a Non-Null Value:

Optional<String> name = Optional.of("Alice");

Note: Optional.of throws a NullPointerException if the value is null.

Optional with a Potentially Null Value:

String nullableValue = null;
Optional<String> maybeName = Optional.ofNullable(nullableValue);

Common Optional Methods

Optional provides a rich API to handle values safely. Here are some key methods:

isPresent(): Returns true if a value exists.
isEmpty() (Java 11+): Returns true if no value exists.
orElse(T other): Returns the value if present, otherwise returns other.
orElseGet(Supplier<? extends T> supplier): Returns the value if present, otherwise invokes the supplier.
orElseThrow(): Throws an exception if no value is present.
map(Function<? super T, ? extends U> mapper): Transforms the value if present.
flatMap(Function<? super T, Optional<U>> mapper): Transforms the value into another Optional.
filter(Predicate<? super T> predicate): Keeps the value if it matches the predicate.

Practical Examples

Let’s dive into some real-world scenarios to see Optional in action.

1. Replacing Null Checks

Without Optional, you might write:

String name = getUserName();
if (name != null) {
    System.out.println(name.toUpperCase());
} else {
    System.out.println("Name not found");
}

With Optional, this becomes more concise:

Optional<String> name = Optional.ofNullable(getUserName());
name.map(String::toUpperCase)
    .ifPresentOrElse(
        System.out::println,
        () -> System.out.println("Name not found")
    );

The Optional version is more fluent and explicit about handling the absence of a value.

2. Chaining Operations

Suppose you want to get a user’s email domain from a database. Without Optional, you’d need multiple null checks:

User user = getUser();
if (user != null) {
    String email = user.getEmail();
    if (email != null) {
        String domain = email.split("@")[1];
        if (domain != null) {
            System.out.println(domain);
        }
    }
}

With Optional, you can chain operations:

Optional<User> user = Optional.ofNullable(getUser());
user.map(User::getEmail)
    .map(email -> email.split("@")[1])
    .ifPresent(System.out::println);

This is more readable and avoids nested null checks.

3. Providing Defaults

You can provide a default value when an Optional is empty:

Optional<String> name = Optional.ofNullable(getUserName());
String result = name.orElse("Anonymous");
System.out.println(result); // Prints "Anonymous" if name is empty

For expensive default operations, use orElseGet:

String result = name.orElseGet(() -> computeExpensiveDefault());

4. Throwing Exceptions

If a missing value is an error condition, you can throw an exception:

String name = Optional.ofNullable(getUserName())
    .orElseThrow(() -> new IllegalStateException("User name is required"));

5. Filtering Values

You can filter values based on a condition:

Optional<String> name = Optional.ofNullable(getUserName());
name.filter(n -> n.length() > 3)
    .ifPresent(System.out::println); // Prints name only if longer than 3 characters

Read complete blog here : https://www.codingshuttle.com/blogs/mastering-optional-in-java-say-goodbye-to-null-pointer-exceptions/

Exploring Java 25: New Features with Example Code

Munaf Badarpura — Mon, 13 Oct 2025 10:14:47 +0000

Java continues to evolve rapidly with its six-month release cycle, and Java 25, released on September 16, 2025, and it brings a lot of enhancements aimed at simplifying development, especially for beginners.

And for advanced users, Java 25 introduced powerful tools. This version focuses on reducing boilerplate code, improving readability, and enhancing performance in concurrent scenarios.

In this blog, we'll dive into the key new features of Java 25 along with practical examples so it makes more sense how they work. Whether you are a new programmer or an experienced developer, these updates make Java more accessible and efficient.

1. Instance Main Methods

One of the most beginner-friendly changes in Java 25 is the support for instance main methods. Traditionally, the entry point for Java programs required a public static void main(String[] args) method. Now, you can omit public, static, and even the String[] args parameter if they're not needed. This simplifies writing quick test programs or scripts.

The JVM follows a specific order to locate the main method:

It first checks for the standard public static void main(String[] args).
If not found, it looks for public static void main().
If only an instance (non-static) main exists, it instantiates the class using a public no-arg constructor and calls the method.
If no valid main is found, it throws an error.

Example

class Test {
    void main() {
        System.out.println("Hello, World!");
        System.out.println("This is Coding Shuttle");
    }
}

In this case, since there's no static main, the JVM creates an instance of Test and invokes the instance main() method.

2. Compact Source Files (Unnamed Classes)

Java 25 introduces compact source files, where you don't need to explicitly declare a class. The compiler implicitly wraps your code in an unnamed, final class with a default no-arg constructor. This is perfect for simple scripts or learning exercises, as it lets you focus on logic without class declarations. However, a launchable main method is mandatory; otherwise, compilation fails.

You can define methods, fields, and use this within the file.

Example: Basic Hello World

void main() {
    System.out.println("Hello, World");
}

Example: With Fields and Methods

String msg = "Hello, World";

void main() {
    printMsg();
}

void printMsg() {
    System.out.println(msg);
}

This code runs as if it's inside an implicit class. The generated class is final and can't be extended or referenced by name.

3. Simplifying Console Input/Output with the IO Helper Class

Console I/O in Java has historically been verbose, requiring classes like BufferedReader and exception handling. Java 25 addresses this with the new java.lang.IO class, providing static methods for simple printing and reading. Since it's in java.lang, no import is needed (though static imports can be used for convenience).

Key methods:

IO.print("text"): Prints without a newline.
IO.println("text"): Prints with a newline.
IO.println(): Prints a blank line.
IO.readln(): Reads a line of input.
IO.readln("Prompt: "): Prompts and reads input.

Example: Printing

import static java.lang.IO.*;

void main() {
    println("Hello, Coding Shuttle!");
}

Example: Input

import static java.lang.IO.*;

void main() {
    var name = readln("What's your name? ");
    println("My Name is, " + name);
}

This eliminates boilerplate, making interactive programs easier for beginners.

4. Automatic Imports of Common APIs

In compact source files, Java 25 automatically makes classes from commonly used packages in java.base (e.g., java.util, java.io) available without explicit imports. This reduces setup time for simple programs.

Example

void main() {
    IO.println("Hello, World!");  // no import needed here
}

Here, IO is accessible directly, streamlining code in unnamed classes.

5. Flexible Constructor Bodies

Constructors in prior Java versions required super(...) or this(...) calls as the first statement. Java 25 relaxes this, allowing statements before these calls in the "prologue" section. However, the prologue can't reference this or instance members (except to initialize uninitialized fields). The "epilogue" (after the call) follows normal rules.

Example

class Parent {
    Parent() {
        IO.println("Parent Class Constructor");
    }
}

class Child extends Parent {
    Child() {
        IO.println("Child Class Constructor");
        super();
    }

    public static void main(String[] args) {
        new Child();
    }
}

Output:

Child Class Constructor
Parent Class Constructor

This feature enables pre-initialization logic, like logging or computations, before calling the superclass constructor.

6. Module Import Declarations

For modular applications, Java 25 adds import module M;, which imports all packages exported by module M. This replaces multiple per-package imports, simplifying code when using libraries like java.sql.

Before

import java.util.*;
import java.sql.*;
import java.nio.file.*;
import javax.sql.*;

public class DataProcessor {
    Path filePath = java.nio.file.Paths.get("data.txt");
    Map<String, Integer> dataMap = new HashMap<>();
    Connection dbConn = DriverManager.getConnection(...);
}

After

import module java.base;
import module java.sql;

public class DataProcessor {
    Path filePath = Paths.get("data.txt");        // from java.base
    Map<String, Integer> dataMap = new HashMap<>(); // from java.base
    Connection dbConn = DriverManager.getConnection(...); // from java.sql
}

This reduces import clutter and improves maintainability.

Read complete blog here : https://www.codingshuttle.com/blogs/what-s-new-in-java-25-top-features-examples-and-enhancements-for-beginners-and-pros/

DEV Community: Munaf Badarpura

Integrating Stripe Payments in Spring Boot: Step-by-Step Beginner’s Guide (2025)

Prerequisites

Step 1: Configuring Stripe in Spring Boot

Step 2: Initiating a Payment Session

Controller for Initiating Payment

Service Logic for Payment Initiation

Step 3: Handling Stripe Webhooks

Webhook Controller

Webhook Handling Logic

Step 4: Testing the Integration

Read complete blog here : https://www.codingshuttle.com/blogs/integrating-stripe-payments-in-spring-boot-step-by-step-beginner-s-guide-2025/

Spring Boot File Upload with Multipart Support: Complete Guide

Different Ways of File Uploading

Why Use Multipart?

Implementation: File Upload with Multipart Support

1. Add the following dependencies in your pom.xml :

2. Create the File Upload Request Model :

3. Define the Entity for File Metadata :

4. Implement the File Upload Service :

5. Create the REST Controller ****:

6. Configure File Upload Limits :

Read complete blog here : https://www.codingshuttle.com/blogs/spring-boot-caching-with-redis-boost-performance-with-fast-operations-2025/

Spring Boot Caching with Redis: Boost Performance with Fast Operations (2025)

Java Executor Framework Tutorial: Simplifying Multithreading with ExecutorService

What is the Executor Framework?

Key Components

Why Use the Executor Framework?

How It Works

Configuring a ThreadPoolExecutor

Submitting Tasks

Example: Submitting a Runnable Task

Shutting Down the Executor

Spring Boot @Scheduled Tutorial: Building Scheduled Tasks with TaskScheduler

What is Task Scheduling in Spring Boot?

Common Use Cases

Setting Up Scheduled Tasks

Steps to Implement

Example Configuration

How @Scheduled Works

Customizing for Concurrency

Asynchronous Task Scheduling

Blocking Behavior

Enabling Async Execution

Benefits of @async

Date and Time API in Java 8+: Best Practices & Common Mistakes

Why Use the Java 8+ Date and Time API?

Best Practices

1. Prefer Specific Types Over General Ones

2. Handle Time Zones Explicitly

3. Use Immutability to Your Advantage

4. Parse and Format with Standard Methods

5. Manage Durations and Periods

6. Avoid Legacy Classes

Common Mistakes to Avoid

1. Ignoring Time Zones

2. Mutating Objects

3. Overusing now() Without Context

4. Manual String Parsing

5. Misusing Instant for Local Operations

Java Records: A Modern Way to Write Immutable Data Classes

What Are Java Records?

Syntax Example

Why Use Records?

Key Features

Creating and Using Records

Instantiation

Immutability in Action

Comparing with Traditional Classes

Mastering Optional in Java: Avoid NullPointerExceptions with Best Practices

What is NullPointerException?

What is Optional?

Why Use Optional?

Creating an Optional

Common Optional Methods

Practical Examples

1. Replacing Null Checks

2. Chaining Operations

3. Providing Defaults

4. Throwing Exceptions

3. Overusing `now()` Without Context

5. Misusing `Instant` for Local Operations