Yes, we're now running our Black Friday Sale. All Access and Pro are 33% off until 2nd December, 2025:
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
Yes, we're now running our Black Friday Sale. All Access and Pro are 33% off until 2nd December, 2025:
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
1. Introduction
When testing Spring Boot applications, it’s common to replace some beans in the application context with mock or spy objects. This allows us to intercept method calls, verify interactions, or override behavior for specific components — all without executing the underlying logic.
Starting with Spring Framework 6.2, a new annotation @MockitoSpyBean was introduced. This addition is part of a broader effort to integrate Mockito more tightly with the Spring TestContext framework, offering developers finer control and more predictable behavior when working with spies.
In this article, we’ll explore what @MockitoSpyBean is, how it differs from the legacy @SpyBean, and how we can use it in modern Spring tests. We’ll also look at a few practical code examples and discuss migration considerations for existing test suites.
2. What is @MockitoSpyBean?
The @MockitoSpyBean annotation is used in Spring tests to wrap an existing bean from the application context in a Mockito spy.
Unlike mocks, spies do not completely replace the original bean. Instead, they allow partial mocking — the real methods are invoked unless explicitly stubbed. This makes them ideal for scenarios where we want to verify method calls or tweak behavior without discarding the bean’s real implementation.
Under the hood, Spring creates the real bean early in the test lifecycle and then wraps it with a Mockito spy. This means that the bean’s dependencies, lifecycle callbacks, and initialization logic still run as usual.
It’s also part of a broader change in Spring Framework 6.2, which introduced the @MockitoBean, @MockitoSpyBean, and related infrastructure, replacing the older @MockBean and @SpyBean with a unified and more flexible design.
3. @SpyBean vs @MockitoSpyBean
Before @MockitoSpyBean existed, we typically used @SpyBean to achieve similar results. At first glance, both annotations seem interchangeable – they allow us to create spies for Spring beans and use Mockito’s verification API. However, their behavior under the hood is different, and this difference becomes significant in complex or proxy-heavy applications.
The older @SpyBean creates a new spy instance using Mockito and then replaces the original bean in the Spring context with that instance. This approach works well for most tests, but this replacement can occasionally disrupt the bean’s proxy chain or lifecycle, especially when using AOP or transactional beans.
On the other hand, @MockitoSpyBean works differently. Instead of creating a replacement, it retrieves the real bean that Spring has already created and wraps it with a spy. As a result, the bean’s internal configuration and proxies remain intact, and its behavior in the test is closer to what happens in production.
This subtle change makes @MockitoSpyBean proxy-safe and more predictable in modern Spring applications. It’s also worth noting that the older annotations are now considered legacy and are expected to be removed in future major Spring versions.
4. @MockitoSpyBean in Action
Now that we understand how @MockitoSpyBean works, let’s write some code to see it in action. Let’s use a previously available code example to see how we migrate the legacy annotations:
@Autowired
OrderRepository orderRepository;
@MockitoSpyBean
NotificationService notificationService;
@MockitoSpyBean
OrderService orderService;
@Test
void givenNotificationServiceIsUsingSpyBean_whenOrderServiceIsCalled_thenNotificationServiceSpyBeanShouldBeInvoked() {
Order orderInput = new Order(null, "Test", 1.0, "17 St Andrews Croft, Leeds ,LS17 7TP");
doReturn(true).when(notificationService)
.raiseAlert(any(Order.class));
Order order = orderService.save(orderInput);
Assertions.assertNotNull(order);
Assertions.assertNotNull(order.getId());
verify(notificationService).notify(any(Order.class));
}As shown in the code above, migrating from the legacy annotations is straightforward. We just replaced the old @SpyBean annotations with @MockitoSpyBean, and the test continued to work without any other changes.
This highlights one of the key benefits of the new annotation. It serves as a drop-in replacement for existing tests while providing a more reliable, framework-level integration between Mockito and the Spring TestContext.
5. Conclusion
In this article, we explored the new @MockitoSpyBean annotation introduced in Spring Framework 6.2.
It provides a modern, framework-level alternative to the older @SpyBean, offering improved functionality, better integration with Spring’s proxy system, and more consistent behavior across different test contexts. By wrapping – rather than replacing – real beans, @MockitoSpyBean preserves the bean’s lifecycle, dependencies, and proxies. This makes it especially useful for integration tests where we want to validate real application logic while retaining the ability to observe or stub specific interactions.
As the Spring ecosystem continues to evolve, @MockitoSpyBean is the recommended choice for new projects and will likely become the standard for spy-based testing in upcoming Spring versions.
As always, the code from the article is available over a GitHub repository.
