Introduction
Working with Spring implies using lots of annotations to configure your application, link components, and manage behaviors. These annotations can be separated into some categories: Initialization annotations, Configuration Specifics annotations, Stereotypes, Behavioral, and Testing.
This overview aims to help you discover some new annotations or to understand briefly what some annotations that you may be seeing in your project do, so you can better understand a little bit what is going on and why they are there. It can help you have some ideas to apply some of those in your project.
In this first article of the series, we will cover an overview of each annotation and briefly explain what each one does. In the following articles, I’ll show you how to use them and some specific use cases for each one.
Initialization Annotations
@Value
This annotation is usually used to inject values from your configuration properties.
@Required
It has the function to mark a dependency as mandatory but it became deprecated.
@Autowired
It allows Spring to link beans from the Spring IoC container.
@lazy
It makes a bean to be late initiated, and not initialized with the application context, but when it is going to be used.
@AliasFor
It allows you to create different names for the same attribute.
@Qualifier
It allows you to define which bean to use when you have two beans with the same type.
@primary
It defines which of the beans with the same type is the default.
@DependsOn
It defines beans that the current beans depend on. It guarantees that all the dependencies will be created first.
@Secured
This annotation specifies which user role (it can be more than one) has access to a method.
@resource
It shows Spring to inject a bean based on its name in a method.
@PreDestroy
Spring will call the method where this annotation is set before a bean is removed from the context.
@PostConstruct
Spring will call the method with this annotation to execute after the bean is created.
@Lookup
It will get the return type of the method to replace its behavior, returning a bean of the same type.
Configuration Specific Annotations
@Import
Indicates one or more components to import, usually classes with @Configuration in it.
@profile
When combined with a bean, it will only make the bean available if the Spring active profile is set to the same value as defined in @profile(”prod”).
@ComponentScan
Used with @Configuration, we can use this annotation to point to Spring where they are located.
@bean
This marks to Spring that the return type of the method is an instance to be created, managed, and injected by the Spring IoC container.
@PropertySource
An annotation used in conjunction with @Configuration to add property sources to the application environment.
@scope
This annotation is used to define the lifetime scope of a bean.
Stereotypes
@Component
This annotation tells Spring that our class needs to be created, managed, and injected as an application bean.
@Configuration
This annotation indicates for Spring that the class is a source of bean definitions.
@Controller
This annotation is a specialization of @Component and has the objective of handling web requests.
@RestController
This annotation is a combination of @Controller with @ResponseBody to make it easier to create RESTful web services.
@Service
This is a specialization of the @Component that aims to hold business logic in it.
@Repository
This annotation is for classes that deal with data persistence.
Behavioral Annotations
@Aspect
This annotation tells Spring that this class is an aspect, meaning this class contains code specific to a cross-cutting concern.
@Transactional
Spring will create a transaction wrapping the class or method and manage its lifecycle.
Test Annotations
@BootstrapWith
You can use this annotation to tell how Spring TestContext should be bootstrapped (you could use this to load only specific configurations to your context).
@ContextConfiguration
This annotation is used to tell how to load and configure the application context for your tests.
@WebAppConfiguration
It loads a web application context in testing.
@ContextHierarchy
It defines the hierarchy of the configurations when configuring the test application context.
@ActiveProfiles
It defines which profile will be used in your test application context.
@TestPropertySource
It helps you to configure the property source that Spring will use in your tests.
@DynamicPropertySource
This allows you to set a method to add dynamic properties to your property source.
@DirtiesContext
It tells Spring to restart the context in testing. Spring by default reuses the context in testing; this will force it to restart.
@TestExecutionListeners
Similar to JUnit, Spring provides some listeners that will execute actions that can be before, after, etc. (just like JUnit @Before).
@RecordApplicationEvents
This annotation will record all the application events published in the application context during a test execution.
@commit
This will tell the transaction to commit after the execution of a test method.
@Rollback
This annotation will make the transaction rollback after the test method execution.
@BeforeTransaction
Defines a behavior that will run before starting a transaction.
@AfterTransaction
Defines a behavior that will happen after the transaction ends.
@sql
This will run SQL in the database when running an integration test.
@SqlGroup
Creates a group of @sql annotations to run when running your integration tests.
Conclusion
In the upcoming articles, we will explain tips, tricks, and use cases for each of these annotations. Stay tuned for detailed guides on leveraging these annotations to enhance your Spring applications.
Follow me!
Top comments (0)