Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of how to use the @ Import annotation in SpringBoot, the content is detailed and easy to understand, the operation is simple and quick, and has a certain reference value. I believe you will gain something after reading this SpringBoot @ Import annotation. Let's take a look.

1. @ Import introduces ordinary classes

The introduction of ordinary classes into @ Import can help us define ordinary classes as Bean. @ Import can be added to the classes corresponding to @ SpringBootApplication (startup class), @ Configuration (configuration class), and @ Component (component class).

Note: @ RestController, @ Service, @ Repository all belong to @ Component

@ SpringBootApplication@Import (ImportBean.class) / / add ImportBean to the IOC container through the @ Import annotation to public class MyBatisApplication {public static void main (String [] args) {SpringApplication.run (MyBatisApplication.class, args);}} II, @ Import introduce configuration classes (@ Configuration decorated classes)

In addition to defining a normal class as Bean,@Import, @ Import can also introduce a @ Configuration modified class (introducing a configuration class) to make the configuration class effective (all Bean under the configuration class are added to the IOC container). It is often used when customizing starter.

If the configuration class is under the standard SpringBoot package structure (under the root of the SpringBootApplication startup class package). There is no need for @ Import to import configuration classes, and SpringBoot does it automatically. The above situation is generally used for @ Configuration configuration classes that are not under the standard SpringBoot package structure. So it is generally used when customizing starter.

@ Configuration (proxyBeanMethods = false) @ Import ({/ / import has two XXXDataConfiguration.XXXPartOneConfiguration.class, XXXDataConfiguration.XXXPartTwoConfiguration.class}) public class XXXDataAutoConfiguration {} public class XXXDataConfiguration {@ Configuration (proxyBeanMethods = false) static class XXXPartOneConfiguration {@ Bean @ ConditionalOnMissingBean public BeanForIoc beanForIoc () {return new BeanForIoc () } @ Configuration (proxyBeanMethods = false) static class XXXPartTwoConfiguration {/ * omits the use of @ Bean * /}} III. @ Import introduces the implementation class of ImportSelector

@ Import can also introduce the implementation class of ImportSelector, defining the Class names returned by the selectImports () method of the ImportSelector interface as bean. Notice the parameter AnnotationMetadata of the selectImports () method, through which we can get all kinds of information about the Class annotated by @ Import. This is particularly useful for passing some parameters. It exists in both SpringBoot's automated configuration and @ EnableXXX (functional annotations).

Public interface ImportSelector {/ * is used to specify the Class name that needs to be registered as bean * when an ImportSelector implementation class is introduced using @ Import on the @ Configuration annotated Class, all the Class names returned in the implementation class are defined as bean. * * all kinds of information about @ Import tagged Class can be obtained through its parameter AnnotationMetadata importingClassMetadata, including its Class name, implemented interface name, parent class name, other comments added, and so on. These additional information can help us to select the Class name that needs to be defined as Spring bean * / String [] selectImports (AnnotationMetadata importingClassMetadata);}

With regard to the use of the ImportSelector implementation class introduced by @ Import, let's give a few simple usage scenarios (the actual development is certainly much more complex than this).

3.1 static import scenario (injecting known classes)

Static scenarios (injecting known classes) can simply return the classes we need to define as bean directly by implementing the ImportSelector class, such as the following example. Let's take a note from EnableXXX and inject a known class XXX through XXXConfigurationSelector.

/ * XXXConfigurationSelector must be used with @ Import * / public class XXXConfigurationSelector implements ImportSelector {@ Override @ NonNull public String [] selectImports (@ NonNull AnnotationMetadata importingClassMetadata) {/ / define the class corresponding to XXX as Bean return new String [] {XXX.class.getName ()} }} / * Note @ Import (XXXConfigurationSelector.class) * / @ Target (ElementType.TYPE) @ Retention (RetentionPolicy.RUNTIME) @ Documented@Import (XXXConfigurationSelector.class) public @ interface EnableXXX {} @ SpringBootApplication@EnableXXX / / make it effective public class MyBatisApplication {public static void main (String [] args) {SpringApplication.run (MyBatisApplication.class, args);} 3.2 dynamic import scenario (injecting classes with specified conditions)

To do this, we need to add all the classes that implement the HelloService interface under the specified package path as bean to the IOC container. The @ ComponentScan annotation is used to help us specify the path. The specific implementation is as follows:

Public interface HelloService {void function ();} public class DynamicSelectImport implements ImportSelector {/ * DynamicSelectImport needs to be used with @ Import () annotation *

* all kinds of information about @ Import annotated Class can be obtained through its parameter AnnotationMetadata importingClassMetadata, including its Class name, implemented interface name, parent class name, and other annotations added. Through this additional information, we can help us to select the Class name * / @ Override public String [] selectImports (AnnotationMetadata importingClassMetadata) {/ / the first step: get the package path specified by ComponentScan String [] basePackages = null. / / @ ComponentScan annotation if (importingClassMetadata.hasAnnotation (ComponentScan.class.getName () {Map annotationAttributes = importingClassMetadata.getAnnotationAttributes (ComponentScan.class.getName ()); basePackages = (String []) annotationAttributes.get ("basePackages") on the class corresponding to the Import annotation } if (basePackages = = null | | basePackages.length = = 0) {/ / ComponentScan defaults to the empty array String basePackage = null; try {/ / @ the package name of the class corresponding to the annotation basePackage = Class.forName (importingClassMetadata.getClassName ()). GetPackage (). GetName () } catch (ClassNotFoundException e) {e.printStackTrace ();} basePackages = new String [] {basePackage};} / / step er, know all classes that implement the HelloService interface under the specified package path (use of ClassPathScanningCandidateComponentProvider) ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider (false); TypeFilter helloServiceFilter = new AssignableTypeFilter (HelloService.class); scanner.addIncludeFilter (helloServiceFilter) Set classes = new HashSet (); for (String basePackage: basePackages) {scanner.findCandidateComponents (basePackage) .forEach (beanDefinition-> classes.add (beanDefinition.getBeanClassName ();} / / third step, return to add to the IOC container to return classes.toArray (new String [0]) } @ Configuration@ComponentScan ("com.tuacy.collect.mybatis") / / specify the path @ Import (DynamicSelectImport.class) public class DynamicSelectConfig {} IV, @ Import introduces the implementation class of ImportBeanDefinitionRegistrar

@ Import introduces the implementation class of ImportBeanDefinitionRegistrar. It is generally used to register bean dynamically. The most important thing is that additional modifications or enhancements can be made to these BeanDefinition. Mybatis @ MapperScan, which we often use, is implemented in this way.

/ * ImportBeanDefinitionRegistrar, we usually implement the ImportBeanDefinitionRegistrar class and then use it with a custom annotation. And on the annotation class @ Import our implementation class. * get some metadata of annotations by customizing the configuration of annotations. Then do the corresponding logic processing in the ImportBeanDefinitionRegistrar implementation class, such as adding the custom annotation tag class to the Spring IOC container. * / public interface ImportBeanDefinitionRegistrar {/ * according to the given annotation metadata of the note, register the bean definition * @ param importingClassMetadata as needed to get the Annotation Metadata * @ param registry BeanDefinitionRegistry of the class of @ Import, and then you can get all the registered BeanDefinition, and then you can make additional modifications or enhancements to these BeanDefinition. * / void registerBeanDefinitions (AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);}

With regard to the use of @ Import to introduce ImportBeanDefinitionRegistrar, it is strongly recommended that you take a look at mybatis's processing source code for @ MapperScan. It's very interesting. We also give a very simple example to let you see the use of ImportBeanDefinitionRegistrar visually, for example, we want to register all classes annotated with BeanIoc under the specified package path as bean.

The specific implementation is as follows:

/ * We will define the package path as bean * / @ Retention (RetentionPolicy.RUNTIME) @ Target (ElementType.TYPE) @ Documentedpublic @ interface BeanIoc {} / *. (specify all BeanIoc annotated classes under the package as bean) * Note the use of @ Import (BeanIocScannerRegister.class) here * / @ Retention (RetentionPolicy.RUNTIME) @ Target (ElementType.TYPE) @ Documented@Import (BeanIocScannerRegister.class) public @ interface BeanIocScan {String [] basePackages () default "" } / * search for all BeanIoc annotated classes under the specified package and add them to the ioc container * / public class BeanIocScannerRegister implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {private final static String PACKAGE_NAME_KEY = "basePackages"; private ResourceLoader resourceLoader; @ Override public void registerBeanDefinitions (AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {/ / 1. Get the path of the package we are searching for: AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap (annotationMetadata.getAnnotationAttributes (BeanIocScan.class.getName (); if (annoAttrs = = null | | annoAttrs.isEmpty ()) {return;} String [] basePackages = (String []) annoAttrs.get (PACKAGE_NAME_KEY); / / 2. Find all the BeanIoc annotated classes under the specified package path and add them to the IOC container to ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner (beanDefinitionRegistry, false); scanner.setResourceLoader (resourceLoader); scanner.addIncludeFilter (new AnnotationTypeFilter (BeanIoc.class)); scanner.scan (basePackages);} @ Override public void setResourceLoader (ResourceLoader resourceLoader) {this.resourceLoader = resourceLoader }} / * use to make BeanIocScan effective * / @ Configuration@BeanIocScan (basePackages = "com.tuacy.collect.mybatis") public class BeanIocScanConfig {} this article on "how to use @ Import annotations in SpringBoot" ends here, thank you for reading! I believe you all have a certain understanding of "how to use the @ Import annotation in SpringBoot". If you want to learn more, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.