首页 Java

# BeanFactory 后处理器

# 实现 @ComponentScan 组件扫描

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class ComponentScanPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

        //手动实现组件扫描
        try {
            ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);
            if (componentScan != null) {
                for (String p : componentScan.basePackages()) {
                    System.out.println(p);
                    String path = "classpath*:" + p.replace(".", "/") + "/**/*.class";
                    CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(path);
                    //创建注解beanName生成器, 用于生成beanName
                    AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
                    for (Resource resource : resources) {
//                    System.out.println(resource);
                        MetadataReader reader = factory.getMetadataReader(resource);
                        AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
//                    System.out.println("类名:" + reader.getClassMetadata().getClassName());
                        //获取注解信息
//                    System.out.println("是否加了@Component:" + annotationMetadata.hasAnnotation(Component.class.getName()));
                        //annotationMetadata.hasMetaAnnotation()能够获取派生注解信息, 即注解的注解(Controller注解中含有Component注解)
//                    System.out.println("是否加了@Component(派生):" + annotationMetadata.hasMetaAnnotation(Component.class.getName()));
                        if (annotationMetadata.hasAnnotation(Component.class.getName())
                                || annotationMetadata.hasMetaAnnotation(Component.class.getName())) {
                            //根据reader获取到的ClassMetadata生成BeanDefinition
                            AbstractBeanDefinition bd = BeanDefinitionBuilder.genericBeanDefinition(reader.getClassMetadata().getClassName()).getBeanDefinition();
                            //强转到DefaultListableBeanFactory(DefaultListableBeanFactory为configurableListableBeanFactory子接口)
                            if (configurableListableBeanFactory instanceof DefaultListableBeanFactory beanFactory) {
                                String beanName = generator.generateBeanName(bd, beanFactory);
                                //注册beanDefinition
                                beanFactory.registerBeanDefinition(beanName, bd);
                            }

                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

# 实现 @Bean 注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class BeanAnnotationPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        if (configurableListableBeanFactory instanceof DefaultListableBeanFactory beanFactory) {
            try {
                CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
                MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/wong/a05/Config.class"));
                //获取含@Bean注解的方法集合
                Set<MethodMetadata> annotatedMethods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());
                for (MethodMetadata method : annotatedMethods) {
                    System.out.println(method);
                    //获取方法上@Bean注解中的属性值
                    String initMethod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();
                    //生成空builder
                    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
                    if (!StringUtils.isNullOrEmpty(initMethod)) {
                        System.out.println(">>>>>>>>>>>不是空的");
                        //设置intiMethod
                        builder.setInitMethodName(initMethod);
                    }
                    //设置工厂方法和工厂类
                    builder.setFactoryMethodOnBean(method.getMethodName(), "config");
                    //设置依赖注入方式为Constructor
                    builder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
                    AbstractBeanDefinition bd = builder.getBeanDefinition();
                    beanFactory.registerBeanDefinition(method.getMethodName(), bd);
                }

            } catch (Exception e) {
                System.out.println(">>>>>出问题了!!!");
            }
        }
    }
}

# 实现 Mapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class MapperPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            Resource[] resources = resolver.getResources("classpath:/com/wong/a05/mapper/**/*.class");
            CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();
            AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();
            for (Resource resource : resources) {
                MetadataReader reader = factory.getMetadataReader(resource);
                ClassMetadata classMetadata = reader.getClassMetadata();
                //判断是否为接口且是否有@Mapper接口
                if (classMetadata.isInterface() && reader.getAnnotationMetadata().hasAnnotation(Mapper.class.getName())) {
                    AbstractBeanDefinition bd = BeanDefinitionBuilder
                            //获取添加bean工厂
                            .genericBeanDefinition(MapperFactoryBean.class)
                            //添加构造器参数
                            .addConstructorArgValue(classMetadata.getClassName())
                            //根据类型自动注入
                            .setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)
                            //获取BeanDefinition
                            .getBeanDefinition();
                    //根据接口创建一个新的BeanDefinition以供生成beanName
                    AbstractBeanDefinition bd2 = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();
                    //使用新生成的BeanDefinition生成beanName
                    String beanName = generator.generateBeanName(bd2, beanDefinitionRegistry);
                    //注册BeanDefinition
                    beanDefinitionRegistry.registerBeanDefinition(beanName, bd);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}