Скачать или смотреть How to Create a Non-Reusable Bean in Spring Boot

Learn how to make unique instances for each injection in Spring Boot by using prototype scope beans.
---
This video is based on the question https://stackoverflow.com/q/74537675/ asked by the user 'Rafael Lima' ( https://stackoverflow.com/u/5679560/ ) and on the answer https://stackoverflow.com/a/74537697/ provided by the user 'Yonatan Karp-Rudin' ( https://stackoverflow.com/u/3899765/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How to create a non reusable bean on springboot

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Create a Non-Reusable Bean in Spring Boot

In Spring Boot, one of the most commonly used features is the ability to create beans with the -Bean annotation. However, when you declare a bean in this manner, it results in a singleton by default, meaning the same instance of the bean is shared across all parts of your application that require it. But what if you need unique instances each time a class requests a particular bean? This requirement often arises with stateful components like the RestTemplateBuilder, where any modifications in one instance affect all others.

In this guide, we will explore how to create a non-reusable bean using the concept of prototype scope in Spring Boot. This will allow you to have distinct instances of a bean for each injection, thereby avoiding unwanted side effects and state issues.

Understanding the Need for Prototype Beans

Before we dive into the solution, let's understand why we might want to create a non-reusable bean:

State Management: Certain beans maintain data that can affect their functionality. If multiple parts of your application modify the same bean instance, it can lead to unexpected behavior and bugs.

Isolation: Each component requires its own instance of the bean to operate independently without interference from other components.

Solution: Creating Prototype Beans

To achieve this, we utilize the -Scope annotation along with the -Bean annotation in our Spring configuration. The prototype scope ensures that Spring creates a new instance of the bean each time it is requested. Here’s how you can do it:

Step-by-Step Implementation

Define Your Bean with Prototype Scope

In your Spring configuration class, define the bean with the -Bean and -Scope annotations as follows:

[[See Video to Reveal this Text or Code Snippet]]

In the example above, every time personPrototype() is called via -Autowired, a new instance of the Person class will be created.

Alternative Approach Using Constant

You can also use a constant for better readability and maintainability:

[[See Video to Reveal this Text or Code Snippet]]

This approach provides the same functionality as using the string "prototype" but is less prone to errors due to typographical mistakes.

Key Considerations

Dependency Management: Remember that if your prototype bean depends on other beans, those beans will still be singleton unless you modify their scopes as well.

Performance: While using prototype beans can provide the isolation you need, keep in mind that creating multiple instances consumes more resources, so use this pattern judiciously.

Conclusion

Creating non-reusable beans in Spring Boot is straightforward with the use of the prototype scope. By defining your beans appropriately, you can prevent unintended side effects that arise from shared states. This design pattern is crucial when dealing with stateful components, ensuring each part of your application works independently and reliably.

By understanding and utilizing the prototype scope, you can enhance the scalability and maintainability of your Spring Boot applications, paving the way for smoother, more effective development.