How do I use dependency injection in Spring?

In Spring, Dependency Injection (DI) means you let the Spring container create and provide the objects your class depends on, instead of manually creating them with new.

The recommended approach in modern Spring is constructor injection.

1. Define a dependency as a Spring bean

import org.springframework.stereotype.Component;

@Component
public class EmailSender {

    public void send(String message) {
        System.out.println("Sending email: " + message);
    }
}

@Component tells Spring: “Create and manage an instance of this class.”

2. Inject it into another bean

import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final EmailSender emailSender;

    public NotificationService(EmailSender emailSender) {
        this.emailSender = emailSender;
    }

    public void notifyUser(String message) {
        emailSender.send(message);
    }
}

Because NotificationService is also a Spring bean, Spring sees its constructor and automatically provides an EmailSender.

In modern Spring, if there is only one constructor, you usually do not need @Autowired on the constructor.

3. Use the service from a controller or another bean

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class NotificationController {

    private final NotificationService notificationService;

    public NotificationController(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    @GetMapping("/notify")
    public String notifyUser() {
        notificationService.notifyUser("Hello from Spring!");
        return "Notification sent";
    }
}

Common DI styles in Spring

Constructor injection — recommended

@Service
public class MyService {

    private final MyDependency myDependency;

    public MyService(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}

Use this most of the time because it:

  • makes dependencies explicit
  • supports immutability with final
  • is easier to test
  • avoids partially initialized objects

Setter injection

@Service
public class MyService {

    private MyDependency myDependency;

    @Autowired
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}

Use setter injection mainly for optional dependencies or dependencies that may change after construction.

Field injection — usually avoid

@Service
public class MyService {

    @Autowired
    private MyDependency myDependency;
}

This works, but it is generally discouraged because it makes testing harder and hides the class’s required dependencies.

Injecting interfaces

A common pattern is to inject an interface rather than a concrete class:

public interface MessageSender {
    void send(String message);
}
import org.springframework.stereotype.Component;

@Component
public class EmailSender implements MessageSender {

    @Override
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final MessageSender messageSender;

    public NotificationService(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public void notifyUser(String message) {
        messageSender.send(message);
    }
}

If there is only one implementation of MessageSender, Spring injects it automatically.

When there are multiple implementations

If multiple beans match the same type, use @Qualifier:

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final MessageSender messageSender;

    public NotificationService(@Qualifier("emailSender") MessageSender messageSender) {
        this.messageSender = messageSender;
    }
}

The qualifier value usually matches the bean name, which by default is the class name with a lowercase-first letter.

Creating beans with @Bean

You can also define beans in a configuration class:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public EmailSender emailSender() {
        return new EmailSender();
    }
}

This is useful when:

  • the class comes from a third-party library
  • construction requires custom setup
  • you do not want to annotate the class with @Component

Summary

Use this pattern most of the time:

@Service
public class MyService {

    private final MyDependency myDependency;

    public MyService(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    public void doWork() {
        myDependency.doSomething();
    }
}

And make sure the dependency is a Spring bean:

@Component
public class MyDependency {

    public void doSomething() {
        System.out.println("Dependency logic executed.");
    }
}

In short: annotate your classes with Spring stereotypes like @Component, @Service, or @Repository, then inject dependencies through constructors.

How do I understand what the Spring Framework actually does?

The easiest way to understand what the Spring Framework actually does is to stop thinking of it as “magic” and start thinking of it as infrastructure code that your application delegates to.

At a high level:

Spring creates objects, wires them together, manages their lifecycle, and adds common behavior around them so you do not have to write that plumbing yourself.


1. The Core Problem Spring Solves

Without Spring, your application code often has to manually do things like:

UserRepository repository = new JdbcUserRepository(dataSource);
EmailService emailService = new SmtpEmailService(config);
UserService userService = new UserService(repository, emailService);

As the application grows, this becomes harder to manage:

  • Who creates each object?
  • In what order?
  • Which implementation should be used?
  • How are shared dependencies reused?
  • How do you add transactions, security, logging, validation, configuration, etc.?

Spring’s answer is:

Declare your application components, and I will create, connect, configure, and enhance them.


2. Spring Is Mainly an Application Container

The heart of Spring is the IoC container.

IoC means Inversion of Control.

Instead of your code controlling object creation:

UserService service = new UserService(new UserRepository());

Spring controls it:

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Then Spring sees:

@Repository
public class UserRepository {
}

And automatically creates:

  • a UserRepository
  • a UserService
  • injects the repository into the service

This is called Dependency Injection.

So Spring’s first major job is:

Managing your application objects, called beans.


3. What Is a Bean?

A Spring bean is simply an object managed by Spring.

For example:

@Service
public class PaymentService {
}

That class becomes a Spring-managed object.

Spring can:

  • create it
  • inject its dependencies
  • configure it
  • call lifecycle methods
  • wrap it with proxies
  • destroy it when the application shuts down

The object itself is ordinary Java. What changes is who manages it.


4. Spring Reads Metadata About Your App

Spring needs to know what objects to manage.

You give it metadata using annotations such as:

@Component
@Service
@Repository
@Controller
@Configuration
@Bean
@Autowired

Example:

@Configuration
public class AppConfig {

    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

This tells Spring:

“When something needs a Clock, use this object.”

Spring scans your code, reads these annotations, builds a registry of beans, and creates an application context.


5. The ApplicationContext Is the Running Spring Container

The ApplicationContext is basically Spring’s runtime environment.

It contains all managed beans.

Conceptually:

ApplicationContext context = ...;

UserService userService = context.getBean(UserService.class);

In most Spring applications, you do not usually call getBean() yourself. Spring injects dependencies automatically.

The container knows:

  • which beans exist
  • how to create them
  • what dependencies they need
  • what order to initialize them in
  • what configuration values they require

6. Spring Adds Behavior Using Proxies

A lot of Spring’s “magic” comes from proxies.

For example, when you write:

@Transactional
public void transferMoney(Account from, Account to, BigDecimal amount) {
    withdraw(from, amount);
    deposit(to, amount);
}

Spring does not rewrite your method.

Instead, it may create a wrapper object around your service.

Conceptually:

beginTransaction();

try {
    transferMoney(...);
    commitTransaction();
} catch (Exception ex) {
    rollbackTransaction();
    throw ex;
}

That wrapper is a proxy.

Spring uses proxies for features like:

  • transactions
  • security
  • caching
  • async methods
  • method validation
  • aspect-oriented programming

So another major thing Spring does is:

It intercepts calls to your objects and adds infrastructure behavior around them.


7. Spring MVC Handles Web Requests

If you use Spring MVC, Spring also acts as a web framework.

You write:

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public UserDto getUser(@PathVariable Long id) {
        return new UserDto(id, "Alice");
    }
}

Spring MVC handles:

  • receiving the HTTP request
  • matching /users/{id} to the method
  • converting path variables
  • calling your controller
  • converting the return value to JSON
  • writing the HTTP response

You focus on:

public UserDto getUser(Long id)

Spring handles the web plumbing.


8. Spring Data JPA Creates Repository Implementations

With Spring Data JPA, you can write:

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

You do not manually implement this interface.

Spring Data creates an implementation at runtime.

It understands method names like:

findByEmail
findByStatus
findByCreatedAtAfter

And turns them into database queries.

So Spring Data JPA does:

  • repository implementation generation
  • query method parsing
  • transaction integration
  • JPA EntityManager management

9. Spring Boot vs Spring Framework

This is an important distinction.

Spring Framework

The Spring Framework provides the core capabilities:

  • dependency injection
  • bean lifecycle
  • transactions
  • Spring MVC
  • validation integration
  • resource loading
  • AOP
  • event system

Spring Boot

Spring Boot sits on top of Spring Framework.

It adds:

  • auto-configuration
  • embedded servers
  • starter dependencies
  • production features
  • simplified project setup

Spring Boot’s job is mostly:

“Based on what dependencies and settings you have, I will configure Spring automatically.”

For example, if Spring Boot sees Spring MVC on the classpath, it configures a web server and MVC infrastructure.

If it sees Spring Data JPA and a database driver, it configures JPA-related beans.


10. A Mental Model

Think of a Spring application like this:

Your code:
  Controllers
  Services
  Repositories
  Entities
  Configuration

Spring:
  Creates objects
  Injects dependencies
  Applies configuration
  Opens transactions
  Handles HTTP requests
  Converts JSON
  Manages validation
  Integrates with databases
  Publishes events
  Handles lifecycle

You write the business logic.

Spring handles the surrounding infrastructure.


11. What Happens at Startup?

Simplified startup flow:

1. Application starts
2. Spring creates an ApplicationContext
3. Spring scans classes and configuration
4. Spring discovers bean definitions
5. Spring creates beans
6. Spring injects dependencies
7. Spring applies post-processors
8. Spring creates proxies where needed
9. Web server starts, if this is a web app
10. App is ready to receive requests

For example:

@SpringBootApplication
public class MyApplication {

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

That one line starts a large amount of framework infrastructure.


12. A Practical Way to Learn Spring

To understand Spring deeply, learn it in this order:

  1. Plain Java object creation
  2. Dependency Injection
  3. Beans and ApplicationContext
  4. Configuration with @Configuration and @Bean
  5. Component scanning with @Component, @Service, @Repository
  6. Bean lifecycle
  7. Spring MVC request handling
  8. Transactions with @Transactional
  9. Spring Data repositories
  10. Spring Boot auto-configuration

Avoid starting with everything at once. Spring feels magical when you learn MVC, JPA, transactions, Boot, security, and annotations simultaneously.


13. Tiny Example

Your code:

@Service
public class GreetingService {

    public String greet(String name) {
        return "Hello, " + name;
    }
}
@RestController
public class GreetingController {

    private final GreetingService greetingService;

    public GreetingController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @GetMapping("/hello")
    public String hello() {
        return greetingService.greet("World");
    }
}

What Spring does:

1. Finds GreetingService
2. Creates a GreetingService object
3. Finds GreetingController
4. Sees that it needs GreetingService
5. Injects GreetingService into GreetingController
6. Maps GET /hello to hello()
7. Calls hello() when an HTTP request arrives
8. Sends "Hello, World" as the response

That is Spring in miniature.


Bottom Line

Spring Framework mainly does four things:

  1. Object management
    It creates and manages your application objects.

  2. Dependency injection
    It wires objects together automatically.

  3. Infrastructure integration
    It provides transactions, web handling, validation, database integration, events, configuration, etc.

  4. Behavior wrapping
    It uses proxies to add behavior such as transactions, security, caching, and async execution.

The shortest explanation is:

Spring is a container and infrastructure framework that lets you write business code while it handles object creation, wiring, lifecycle, and common enterprise concerns.

How to Use Virtual Threads in Java (Project Loom) with Spring Boot

Virtual threads are one of the most exciting additions to modern Java. They make it much easier to write highly concurrent applications without the complexity of managing large thread pools, callbacks, or reactive pipelines.

If you build applications with Spring Boot, virtual threads can help your app handle many more concurrent tasks with simpler code.

In this post, we’ll cover:

  • What virtual threads are
  • Why they matter
  • When to use them
  • How to enable them in Spring Boot
  • A few important best practices and warnings

What are virtual threads?

Traditional Java threads are often called platform threads. They are mapped closely to operating system threads. That means they are relatively expensive in terms of memory and scheduling.

Virtual threads are lightweight threads managed by the JVM, not directly by the operating system. They are designed to make blocking code cheap again.

In simple terms:

  • Platform threads = heavier, fewer, more expensive
  • Virtual threads = lightweight, many more, cheaper to create

This means you can write code in the usual imperative style, but still support high concurrency.


Why virtual threads matter

For years, Java developers had two main choices for handling concurrency:

  1. Use thread pools and blocking code
  2. Use asynchronous/reactive programming

Virtual threads give you a third option:

  • Keep the simple blocking style
  • Avoid the complexity of reactive code
  • Scale better under lots of concurrent I/O operations

This is especially useful for applications that spend a lot of time waiting on:

  • Database calls
  • HTTP requests
  • File I/O
  • Remote service calls

If your application is mostly I/O-bound, virtual threads can be a great fit.


Virtual threads vs platform threads

Here’s a simple comparison:

Feature Platform Threads Virtual Threads
Cost to create Higher Very low
Memory usage Higher Lower
Number you can run Limited Much larger
Good for blocking code Yes, but expensive Yes, and efficient
Managed by OS Yes Mostly by JVM

The biggest win is that virtual threads let you run many blocking tasks concurrently without exhausting thread resources as quickly.


When should you use virtual threads?

Virtual threads are a strong choice when your app does lots of blocking I/O and you want simple code.

Good use cases:

  • REST APIs with many simultaneous requests
  • Service-to-service communication
  • Database-heavy applications
  • Background jobs that wait on I/O
  • File processing or batch operations

Less ideal use cases:

  • CPU-intensive tasks
  • Work that depends heavily on thread-local assumptions
  • Libraries that block while holding locks in a problematic way

Virtual threads do not magically make CPU-bound code faster. They help most when threads spend time waiting.


Project Loom in Java

Virtual threads are part of Project Loom, a long-running effort to modernize concurrency in Java.

Loom also introduced other improvements around structured concurrency and scoped values, but the headline feature most developers use today is virtual threads.

Virtual threads became a standard Java feature in recent releases, so you no longer need special preview settings in modern Java versions.


How Spring Boot supports virtual threads

Spring Boot has first-class support for virtual threads.

If you are using Spring Boot 3.2+, you can usually enable them with a simple configuration property:

spring.threads.virtual.enabled=true

That tells Spring Boot to use virtual threads in places where it manages request handling and task execution.

This is one of the nicest parts: in many cases, you can get the benefits of virtual threads with very little code change.


Basic setup in Spring Boot

1. Use a recent Java version

Virtual threads require a modern JDK, for example Java 25.

2. Use a recent Spring Boot version

Make sure your Spring Boot version supports virtual threads well. Spring Boot 3.2 or later is recommended.

3. Enable virtual threads

Add this to your application configuration:

spring.threads.virtual.enabled=true

Or in YAML:

spring:
  threads:
    virtual:
      enabled: true

That’s often enough for web applications.


What happens when you enable them?

When virtual threads are enabled, Spring can use them for tasks such as:

  • Handling incoming HTTP requests
  • Running @Async methods
  • Executing some scheduled or background tasks

The exact behavior depends on the Spring component and configuration, but the overall idea is that work can run on virtual threads instead of a small pool of platform threads.


Example: a Spring Boot REST controller

Here is a simple example of how your code can stay clean and blocking while still benefiting from virtual threads.

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    private final DemoService demoService;

    public DemoController(DemoService demoService) {
        this.demoService = demoService;
    }

    @GetMapping("/hello")
    public String hello() {
        return demoService.fetchMessage();
    }
}
package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class DemoService {

    public String fetchMessage() {
        // Simulate a blocking operation
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Hello from a virtual thread!";
    }
}

With virtual threads enabled, each request can be handled with a lightweight thread, even though the service method blocks.


Example: using virtual threads for background tasks

You can also create virtual threads manually when needed.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadExample {

    public static void main(String[] args) {
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.submit(() -> System.out.println("Task 1 on virtual thread"));
            executor.submit(() -> System.out.println("Task 2 on another virtual thread"));
        }
    }
}

This is useful when you want a simple executor that creates a new virtual thread for each task.


Using @Async with virtual threads

Spring’s @Async support can also benefit from virtual threads.

For example:

package com.example.demo;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;

@Service
public class EmailService {

    @Async
    public CompletableFuture<String> sendEmail() {
        // Simulate work
        return CompletableFuture.completedFuture("Email sent");
    }
}

If Spring is configured to use virtual threads for task execution, these async methods can run on virtual threads, making blocking work much cheaper.


Virtual threads do not replace everything

It’s important not to oversell virtual threads. They solve one problem very well: cheap blocking concurrency.

They do not replace:

  • Proper database indexing
  • Efficient network design
  • Good application architecture
  • Caching
  • Load balancing
  • Performance tuning

Virtual threads are a concurrency tool, not a performance silver bullet.


Best practices when using virtual threads

1. Keep code simple

One of the main advantages of virtual threads is that you can keep using normal blocking code. Don’t add unnecessary complexity.

2. Avoid long synchronized blocks

Virtual threads can behave poorly if they spend too much time blocked inside synchronized sections. Prefer shorter critical sections and consider alternatives where appropriate.

3. Watch out for thread-local usage

Some older code relies heavily on ThreadLocal. Virtual threads support it, but large-scale usage can still create complexity and memory overhead.

4. Test your dependencies

Most modern libraries work well, but some older libraries may assume platform-thread behavior or may not play nicely with high concurrency.

5. Don’t use virtual threads for CPU-heavy work expecting miracles

If your bottleneck is CPU, virtual threads will not fix it. For CPU-bound tasks, focus on algorithms, parallelism, and profiling.


Common questions

Are virtual threads faster?

Not always in a direct “single task runs faster” sense. Their big advantage is that they allow more concurrency with less overhead, especially for blocking I/O.

Do I need reactive programming anymore?

Not necessarily. Virtual threads reduce the need for reactive programming in many applications, especially if you prefer imperative code.

Can I use virtual threads with Spring MVC?

Yes. Spring MVC is a great fit because it already uses a blocking request model, which maps naturally to virtual threads.

Can I use them with Spring WebFlux?

You can, but WebFlux is built around a reactive model. Virtual threads are often more valuable in traditional blocking stacks like Spring MVC.


When virtual threads are a great fit in Spring Boot

Virtual threads are especially attractive if:

  • You already have a Spring MVC application
  • You use JDBC and blocking database access
  • Your codebase is imperative and you want to keep it that way
  • You want to handle more concurrent requests with less thread-pool tuning

In many cases, virtual threads let you modernize your app without rewriting it.


A practical migration strategy

If you want to adopt virtual threads in an existing Spring Boot app, here’s a simple approach:

  1. Upgrade to a compatible Java and Spring Boot version
  2. Enable virtual threads in configuration
  3. Test your main request paths
  4. Watch application metrics under load
  5. Check library compatibility
  6. Tune only where needed

You usually do not need to rewrite your whole application.


Final thoughts

Virtual threads are a major step forward for Java concurrency. They make it possible to write straightforward, blocking-style code while still supporting high throughput and scalability.

For Spring Boot developers, this is especially valuable because it means:

  • Less concurrency boilerplate
  • Easier-to-read code
  • Better scaling for I/O-heavy workloads
  • A smoother path than fully reactive programming for many apps

If your application spends a lot of time waiting on I/O, virtual threads are absolutely worth trying.


Summary

Use virtual threads in Spring Boot when you want:

  • Simple blocking code
  • High concurrency
  • Less thread-pool management
  • Better scalability for I/O-bound workloads

Enable them with:

spring.threads.virtual.enabled=true

Then test, measure, and enjoy a much simpler concurrency model in Java.

How do I map a request to a controller in Spring MVC?

In Spring MVC, you can map a request to a controller using the @RequestMapping (or aliases like @GetMapping, @PostMapping, etc.) annotation on a method. These annotations define a specific URL path and HTTP method that the method will handle. Here’s how you can do it:

Step-by-Step Instructions:

  1. Annotate the Class as a Controller: Use the @Controller annotation (or @RestController for REST APIs) on the class to indicate that it is a controller in your Spring application.
  2. Map URLs with @RequestMapping: Use the @RequestMapping annotation on methods to specify the URL patterns you want to map HTTP requests to. You can also use HTTP method-specific annotations, such as @GetMapping and @PostMapping.

Example

package org.kodejava.app;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/my-controller") // Base path for all endpoints in the controller
public class MyController {

    // Handles GET requests to /my-controller/hello
    @GetMapping("/hello")
    @ResponseBody
    public String sayHello() {
        return "Hello, World!";
    }

    // Handles POST requests to /my-controller/data
    @PostMapping("/data")
    @ResponseBody
    public String handleDataSubmission() {
        return "Data submitted successfully!";
    }
}

Key Annotations:

  1. @Controller: Marks the class as a Spring MVC controller.
  2. @RequestMapping: Used to map web requests onto specific methods or classes. It can be used with a combination of HTTP methods, URL patterns, and request parameters.
    @RequestMapping(value = "/example", method = RequestMethod.GET)
    
  3. HTTP Method-Specific Annotations: These are shorthand annotations for specific HTTP methods:
    • @GetMapping for GET requests
    • @PostMapping for POST requests
    • @PutMapping for PUT requests
    • @DeleteMapping for DELETE requests
    • @PatchMapping for PATCH requests

Notes:

  1. Class-Level @RequestMapping: If you specify a base path with @RequestMapping at the class level, all methods will inherit this as part of their path.
  2. Return Types:
    • Use @ResponseBody to return plain text, JSON, or XML directly in the HTTP response body.
    • If you are returning a view name, you don’t need @ResponseBody.
  3. Path Variables and Query Parameters: You can also handle dynamic path variables using the @PathVariable and request parameters using the @RequestParam annotations.

Example with Path Variables and Request Parameters:

package org.kodejava.app;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    // Dynamic path variable
    @GetMapping("/{id}")
    public String getUserById(@PathVariable("id") Long id) {
        return "User ID: " + id;
    }

    // Query parameter
    @GetMapping("/search")
    public String searchUsers(@RequestParam("name") String name) {
        return "Searching for user: " + name;
    }
}

By following this pattern, you can map requests to specific controller methods and build robust web applications with Spring MVC.

Testing Spring Boot Applications with JUnit and Mockito

Testing Spring Boot applications with JUnit and Mockito is a good practice to ensure the correctness and reliability of your application. Below, I’ll present a brief overview of how to write such test cases with explanations and examples.

1. JUnit Basics in Spring Boot

Spring Boot provides out-of-the-box support for JUnit through the spring-boot-starter-test dependency, which includes:

  • JUnit 5 (Jupiter) for writing test cases.
  • Mockito for mocking dependencies.
  • Additional libraries like Hamcrest and AssertJ for assertions.

Add the dependency in your pom.xml (if it’s not already present):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

2. Structural Overview

Testing can be divided into:

  • Unit Tests: Independent and isolated tests of individual classes, written using JUnit + Mockito.
  • Integration Tests: Testing multiple layers/classes, typically with Spring’s @SpringBootTest.

3. Writing Unit Tests with JUnit and Mockito

Below is an example of unit testing a Service class.

Example Scenario:

We have a class that depends on UserRepository. UserService
UserService.java:

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User findUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new RuntimeException("User not found"));
    }
}

UserRepository.java:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

Corresponding Test Case

@ExtendWith(MockitoExtension.class) // Enables Mockito in JUnit 5
class UserServiceTest {

    @Mock // Creates a mock instance of UserRepository
    private UserRepository userRepository;

    @InjectMocks // Creates UserService and injects the mock UserRepository
    private UserService userService;

    @Test
    void testFindUserById_UserExists() {
        // Arrange
        Long userId = 1L;
        User mockUser = new User(userId, "John Doe", "[email protected]");

        // Mock the behavior of userRepository
        Mockito.when(userRepository.findById(userId)).thenReturn(Optional.of(mockUser));

        // Act
        User result = userService.findUserById(userId);

        // Assert
        assertNotNull(result);
        assertEquals(mockUser.getName(), result.getName());
        Mockito.verify(userRepository).findById(userId); // Verify method call
    }

    @Test
    void testFindUserById_UserNotFound() {
        // Arrange
        Long userId = 1L;

        // Mock the behavior of userRepository
        Mockito.when(userRepository.findById(userId)).thenReturn(Optional.empty());

        // Act & Assert
        Exception exception = assertThrows(RuntimeException.class, () -> userService.findUserById(userId));
        assertEquals("User not found", exception.getMessage());
    }
}

4. Integration Tests with @SpringBootTest

Integration tests are used to test the entire Spring application context.

Testing UserController

UserController.java:

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findUserById(id));
    }
}

Test Case for UserController

Use @SpringBootTest with for integration-like testing. MockMvc

@SpringBootTest
@AutoConfigureMockMvc // Configures MockMvc
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean // Mock a bean in the Spring context
    private UserService userService;

    @Test
    void testGetUserById() throws Exception {
        // Arrange
        Long userId = 1L;
        User mockUser = new User(userId, "John Doe", "[email protected]");

        Mockito.when(userService.findUserById(userId)).thenReturn(mockUser);

        // Act and Assert
        mockMvc.perform(get("/users/{id}", userId))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("John Doe"))
               .andExpect(jsonPath("$.email").value("[email protected]"));

        Mockito.verify(userService).findUserById(userId);
    }
}

5. Tips for Effective Testing

  1. Mock dependencies: Mock all external dependencies to isolate the unit being tested.
  2. Use Assertions effectively: Leverage libraries like AssertJ or Hamcrest for expressive assertions.
  3. Test exceptions: Always test boundary cases and exceptions.
  4. Verify mock behavior: Use Mockito.verify() to ensure mocked methods were invoked correctly.
  5. Spring utilities: @MockBean is useful for overriding beans in the application context for integration testing.

Summary

Spring Boot testing with JUnit and Mockito allows you to:

  • Write isolated unit tests for business logic.
  • Write integration tests to validate Spring components working together.