Introduction to the three core annotations of Spring Boot (with code)

This article brings you an introduction to the three core annotations of Spring Boot (with code). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

I recently interviewed some Java developers. Some of them have actually used Spring Boot in the company, and some have learned it in their spare time as a hobby. However, when I asked them what the three core annotations of Spring Boot were, I was disappointed that few people could answer them. In this way, can you say that you know Spring Boot very well? This may also cost you points!

Explanation of Spring Boot core annotations

The biggest feature of Spring Boot is that it does not require XML configuration files, can automatically scan the package path to load and inject objects, and can do it according to the classpath The jar package under is automatically configured.

So the three core annotations of Spring Boot are:

1, @Configuration

org.springframework.context.annotation.Configuration

This is an annotation added by Spring 3.0 to replace the applicationContext.xml configuration file. All things that can be done in this configuration file can be registered through the class where this annotation is located.

The following related considerations are also very important!

@Bean

is used to replace the configuration in the XML configuration file.

@ImportResource

If some cannot be configured through class registration, you can introduce additional XML configuration files through this annotation. Some old configuration files cannot be passed@Configuration The configuration method is very useful.

@Import

Used to introduce one or more additional @Configuration modified configuration file classes.

@SpringBootConfiguration

This annotation is a variant of the @Configuration annotation. It is only used to modify the Spring Boot configuration, or to facilitate the subsequent expansion of Spring Boot. Source code as follows.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

2, @ComponentScan

org.springframework.context.annotation.ComponentScan

This is an annotation added by Spring 3.1 to replace The component-scan configuration in the configuration file turns on component scanning, that is, it automatically scans the @Component annotation under the package path to register the bean instance into the context.

In addition, @ComponentScans is a repeatable annotation, that is, multiple annotations can be configured to configure and register different sub-packages.

3, @EnableAutoConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration

You can tell by looking at the full path, this is since the birth of Spring Boot The added annotations are used to provide automatic configuration. The above two are under the spring-context package and do not belong to Spring Boot. Therefore, the XML configuration method after Spring 3.0 has been laid down for Spring Boot. Foreshadowing!

For more detailed usage and actual combat of automatic configuration, please read this article "Spring Boot Automatic Configuration Principles and Practical Combat".

The last easter egg

Now that the three core annotations of Spring Boot have been introduced, you may have questions, why is the most important annotation @SpringBootApplication not among them?

An Easter egg for everyone, in fact, this @SpringBootApplication annotation contains the above three main annotations. If there is no need for custom configuration, just use the @SpringBootApplication annotation!

Let us take a look at the source code of the @SpringBootApplication annotation, everything is clear!

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

    ...

}

The above is the detailed content of Introduction to the three core annotations of Spring Boot (with code). For more information, please follow other related articles on the PHP Chinese website!