HM-SpringBoot2.4【SpringBoot自动配置-Import注解】

1 导入Bean

1 package com.haifei.domain;
2 
3 public class User {
4 }

 1 package com.haifei.config;
 2 
 3 import com.haifei.domain.User;
 4 import org.springframework.context.annotation.Bean;
 5 import org.springframework.context.annotation.Configuration;
 6 
 7 @Configuration
 8 public class UserConfig {
 9 
10     @Bean
11     public User user(){
12         return new User();
13     }
14 
15 }

 1 package com.haifei.springboot9enable;
 2 
 3 import com.haifei.config.UserConfig;
 4 import com.haifei.domain.User;
 5 import org.springframework.boot.SpringApplication;
 6 import org.springframework.boot.autoconfigure.SpringBootApplication;
 7 import org.springframework.context.ConfigurableApplicationContext;
 8 import org.springframework.context.annotation.Import;
 9 
10 import java.util.Map;
11 
12 
13 /**
14  * Import注解的4种用法：
15  *  1. 导入Bean
16  *  2. 导入配置类
17  *  3. 导入ImportSelector的实现类
18  *  4. 导入ImportBeanDefinitionRegistrar实现类
19  */
20 @Import(User.class)
21 
22 @SpringBootApplication
23 public class Springboot9EnableApplication2 {
24 
25     public static void main(String[] args) {
26         ConfigurableApplicationContext context = SpringApplication.run(Springboot9EnableApplication2.class, args);
27         User user = context.getBean(User.class);
28         System.out.println(user); //com.haifei.domain.User@253d9f73
29 
30         Map<String, User> map = context.getBeansOfType(User.class);
31         System.out.println(map); //{com.haifei.domain.User=com.haifei.domain.User@77258e59
32     }
33 
34 }

2 导入配置类

1 package com.haifei.domain;
2 
3 public class Role {
4 }

 1 package com.haifei.config;
 2 
 3 import com.haifei.domain.Role;
 4 import com.haifei.domain.User;
 5 import org.springframework.context.annotation.Bean;
 6 import org.springframework.context.annotation.Configuration;
 7 
 8 //@Configuration //@Import导入配置类时，配置类的@Configuration可以省略，也可以有
 9 public class UserConfig {
10 
11     @Bean
12     public User user(){
13         return new User();
14     }
15 
16     @Bean
17     public Role role(){
18         return new Role();
19     }
20 
21 }

 1 package com.haifei.springboot9enable;
 2 
 3 import com.haifei.config.UserConfig;
 4 import com.haifei.domain.Role;
 5 import com.haifei.domain.User;
 6 import org.springframework.boot.SpringApplication;
 7 import org.springframework.boot.autoconfigure.SpringBootApplication;
 8 import org.springframework.context.ConfigurableApplicationContext;
 9 import org.springframework.context.annotation.Import;
10 
11 import java.util.Map;
12 
13 
14 /**
15  * Import注解的4种用法：
16  *  1. 导入Bean
17  *  2. 导入配置类
18  *  3. 导入ImportSelector的实现类
19  *  4. 导入ImportBeanDefinitionRegistrar实现类
20  */
21 //@Import(User.class) //导入Bean
22 @Import(UserConfig.class) //导入配置类
23 
24 @SpringBootApplication
25 public class Springboot9EnableApplication2 {
26 
27     public static void main(String[] args) {
28         ConfigurableApplicationContext context = SpringApplication.run(Springboot9EnableApplication2.class, args);
29 
30         //导入Bean
31         /*User user = context.getBean(User.class);
32         System.out.println(user); //com.haifei.domain.User@253d9f73
33         Map<String, User> map = context.getBeansOfType(User.class);
34         System.out.println(map); //{com.haifei.domain.User=com.haifei.domain.User@77258e59*/
35 
36         //导入配置类
37         User user = context.getBean(User.class);
38         System.out.println(user); //com.haifei.domain.User@64b73e7a
39         Role role = context.getBean(Role.class);
40         System.out.println(role); //com.haifei.domain.Role@530712d
41     }
42 
43 }

3 导入ImportSelector的实现类

 1 package com.haifei.config;
 2 
 3 import org.springframework.context.annotation.ImportSelector;
 4 import org.springframework.core.type.AnnotationMetadata;
 5 
 6 public class MyImportSelector implements ImportSelector {
 7 
 8     @Override
 9     public String[] selectImports(AnnotationMetadata annotationMetadata) {
10         return new String[]{
11                 "com.haifei.domain.User",
12                 "com.haifei.domain.Role" //这些参数可以配置到配置文件中，读取后放到这里，解耦
13         };
14     }
15 
16 }

 1 package com.haifei.springboot9enable;
 2 
 3 import com.haifei.config.MyImportSelector;
 4 import com.haifei.config.UserConfig;
 5 import com.haifei.domain.Role;
 6 import com.haifei.domain.User;
 7 import org.springframework.boot.SpringApplication;
 8 import org.springframework.boot.autoconfigure.SpringBootApplication;
 9 import org.springframework.context.ConfigurableApplicationContext;
10 import org.springframework.context.annotation.Import;
11 
12 import java.util.Map;
13 
14 
15 /**
16  * Import注解的4种用法：
17  *  1. 导入Bean
18  *  2. 导入配置类
19  *  3. 导入ImportSelector的实现类
20  *  4. 导入ImportBeanDefinitionRegistrar实现类
21  */
22 //@Import(User.class) //导入Bean
23 //@Import(UserConfig.class) //导入配置类
24 @Import(MyImportSelector.class) //导入ImportSelector的(自定义)实现类MyImportSelector
25 
26 @SpringBootApplication
27 public class Springboot9EnableApplication2 {
28 
29     public static void main(String[] args) {
30         ConfigurableApplicationContext context = SpringApplication.run(Springboot9EnableApplication2.class, args);
31 
32         //导入Bean
33         /*User user = context.getBean(User.class);
34         System.out.println(user); //com.haifei.domain.User@253d9f73
35         Map<String, User> map = context.getBeansOfType(User.class);
36         System.out.println(map); //{com.haifei.domain.User=com.haifei.domain.User@77258e59*/
37 
38         //导入配置类/导入ImportSelector的实现类
39         User user = context.getBean(User.class);
40         System.out.println(user); //com.haifei.domain.User@64b73e7a
41         Role role = context.getBean(Role.class);
42         System.out.println(role); //com.haifei.domain.Role@530712d
43     }
44 
45 }

4 导入ImportBeanDefinitionRegistrar的实现类

 1 package com.haifei.config;
 2 
 3 import com.haifei.domain.Role;
 4 import com.haifei.domain.User;
 5 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 6 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 7 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 8 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
 9 import org.springframework.core.type.AnnotationMetadata;
10 
11 public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
12 
13     @Override
14     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
15         AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
16         registry.registerBeanDefinition("user", beanDefinition);
17         AbstractBeanDefinition beanDefinition2 = BeanDefinitionBuilder.rootBeanDefinition(Role.class).getBeanDefinition();
18         registry.registerBeanDefinition("role", beanDefinition2);
19     }
20 }

 1 package com.haifei.springboot9enable;
 2 
 3 import com.haifei.config.MyImportBeanDefinitionRegistrar;
 4 import com.haifei.config.MyImportSelector;
 5 import com.haifei.config.UserConfig;
 6 import com.haifei.domain.Role;
 7 import com.haifei.domain.User;
 8 import org.springframework.boot.SpringApplication;
 9 import org.springframework.boot.autoconfigure.SpringBootApplication;
10 import org.springframework.context.ConfigurableApplicationContext;
11 import org.springframework.context.annotation.Import;
12 
13 import java.util.Map;
14 
15 
16 /**
17  * Import注解的4种用法：
18  *  1. 导入Bean
19  *  2. 导入配置类
20  *  3. 导入ImportSelector的实现类
21  *  4. 导入ImportBeanDefinitionRegistrar的实现类
22  */
23 //@Import(User.class) //导入Bean
24 //@Import(UserConfig.class) //导入配置类
25 //@Import(MyImportSelector.class) //导入ImportSelector的(自定义)实现类MyImportSelector
26 @Import(MyImportBeanDefinitionRegistrar.class) //导入ImportBeanDefinitionRegistrar的(自定义)实现类MyImportBeanDefinitionRegistrar
27 
28 
29 @SpringBootApplication
30 public class Springboot9EnableApplication2 {
31 
32     public static void main(String[] args) {
33         ConfigurableApplicationContext context = SpringApplication.run(Springboot9EnableApplication2.class, args);
34 
35         //导入Bean
36         /*User user = context.getBean(User.class);
37         System.out.println(user); //com.haifei.domain.User@253d9f73
38         Map<String, User> map = context.getBeansOfType(User.class);
39         System.out.println(map); //{com.haifei.domain.User=com.haifei.domain.User@77258e59*/
40 
41         //导入配置类 & 导入ImportSelector的实现类
42         /*User user = context.getBean(User.class);
43         System.out.println(user); //com.haifei.domain.User@64b73e7a
44         Role role = context.getBean(Role.class);
45         System.out.println(role); //com.haifei.domain.Role@530712d
46         */
47 
48         //导入ImportBeanDefinitionRegistrar的实现类
49         User user = context.getBean(User.class);
50         System.out.println(user); //com.haifei.domain.User@61a88b8c
51         Role role = context.getBean(Role.class);
52         System.out.println(role); //com.haifei.domain.Role@22295ec4
53         Object user1 = context.getBean("user");
54         System.out.println(user1); //com.haifei.domain.User@61a88b8c
55         Object role1 = context.getBean("role");
56         System.out.println(role1); //com.haifei.domain.Role@22295ec4
57     }
58 
59 }