BeanDefinitionRegistryPostProcessor扩展

ゝ一纸荒年。 2023-06-27 08:42 16阅读 0赞

通过`BeanDefinitionRegistryPostProcessor`扩展能实现额外的很多功能，例如实现将一个接口动态代理，并将该代理对象在spring容器初始化完成前注册到spring容器中。实现可以通过@Autowired等注释或其他方法从spring容器中获取该代理对象。

#### 代理工厂 ####

import lombok.extern.slf4j.Slf4j;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    @Slf4j
    public class HelloProxy implements InvocationHandler { 
    
        private Class<?> interfaceClass;
    
        public Object bind(Class<?> cls) { 
            this.interfaceClass = cls;
            return Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{ interfaceClass}, this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) { 
            log.info("调用代理方法, method: {}", method.getName());
            return "hello world";
        }
    
    }

import org.springframework.beans.factory.FactoryBean;
    
    public class ProxyBeanFactory<T> implements FactoryBean<T> { 
    
        private Class<T> interfaceClass;
    
        public Class<T> getInterfaceClass() { 
            return interfaceClass;
        }
    
        public void setInterfaceClass(Class<T> interfaceClass) { 
            this.interfaceClass = interfaceClass;
        }
    
        @Override
        public T getObject() { 
            return (T) new HelloProxy().bind(interfaceClass);
        }
    
        @Override
        public Class<?> getObjectType() { 
            return interfaceClass;
        }
    
        @Override
        public boolean isSingleton() { 
            // 单例模式
            return true;
        }
    
    }

#### 扫描注册 ####

import com.wakzz.autowire.proxy.ProxyBeanFactory;
    import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
    import org.springframework.beans.factory.config.BeanDefinitionHolder;
    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.GenericBeanDefinition;
    import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
    import org.springframework.core.type.classreading.MetadataReader;
    import org.springframework.core.type.classreading.MetadataReaderFactory;
    import org.springframework.core.type.filter.AnnotationTypeFilter;
    import org.springframework.core.type.filter.TypeFilter;
    
    import java.lang.annotation.Annotation;
    import java.util.Set;
    
    public class ClassPathReferenceScanner extends ClassPathBeanDefinitionScanner { 
    
        private BeanDefinitionRegistry registry;
        private Class<? extends Annotation> annotationClass;
    
        public ClassPathReferenceScanner(BeanDefinitionRegistry registry) { 
            super(registry, false);
            this.registry = registry;
        }
    
        public void setAnnotationClass(Class<? extends Annotation> annotationClass) { 
            this.annotationClass = annotationClass;
        }
    
        /** * 只扫描出指定Annotation注解的类 */
        public void registerFilters() { 
            if (this.annotationClass != null) { 
                addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
            }
    
            // exclude package-info.java
            addExcludeFilter(new TypeFilter() { 
                @Override
                public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) { 
                    String className = metadataReader.getClassMetadata().getClassName();
                    return className.endsWith("package-info");
                }
            });
        }
    
        /** * 只扫描出接口类 */
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { 
            return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
        }
    
        @Override
        public Set<BeanDefinitionHolder> doScan(String... basePackages) { 
            Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
            processBeanDefinitions(beanDefinitions);
            return beanDefinitions;
        }
    
        /** * 将扫描出的类实现代理类,并注册到spring中 */
        private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { 
            for (BeanDefinitionHolder holder : beanDefinitions) { 
                String className = holder.getBeanDefinition().getBeanClassName();
    
                BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(className);
                GenericBeanDefinition proxyDefinition = (GenericBeanDefinition) builder.getRawBeanDefinition();
                proxyDefinition.getPropertyValues().add("interfaceClass", className);
                proxyDefinition.setBeanClass(ProxyBeanFactory.class);
                proxyDefinition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
                this.registry.registerBeanDefinition(holder.getBeanName(), proxyDefinition);
            }
        }
    }

import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    
    import java.lang.annotation.Annotation;
    
    public class ReferenceRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware { 
    
        private String basePackage;
    
        private Class<? extends Annotation> annotationClass;
    
        private ApplicationContext applicationContext;
    
        public void setBasePackage(String basePackage) { 
            this.basePackage = basePackage;
        }
    
        public void setAnnotationClass(Class<? extends Annotation> annotationClass) { 
            this.annotationClass = annotationClass;
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) { 
            this.applicationContext = applicationContext;
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
        }
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
            ClassPathReferenceScanner scanner = new ClassPathReferenceScanner(registry);
            scanner.setAnnotationClass(this.annotationClass);
            scanner.setResourceLoader(this.applicationContext);
            scanner.registerFilters();
            scanner.scan(basePackage);
        }
    
        @Override
        public void afterPropertiesSet() { 
        }
    
        @Override
        public void setBeanName(String name) { 
        }
    }

#### 注入实现 ####

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Reference { 
    }

import com.wakzz.autowire.Reference;
    
    @Reference
    public interface TestService { 
    
        String sayHello();
    
    }

import com.wakzz.autowire.Reference;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class ReferenceConfig { 
    
        @Bean
        public BeanDefinitionRegistryPostProcessor referenceRegistryPostProcessor() { 
            ReferenceRegistryPostProcessor referenceRegistryPostProcessor = new ReferenceRegistryPostProcessor();
            referenceRegistryPostProcessor.setAnnotationClass(Reference.class);
            referenceRegistryPostProcessor.setBasePackage("com.wakzz.autowire");
            return referenceRegistryPostProcessor;
        }
    
    }

#### 效果 ####

ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder()
    		.sources(Application.class)
    		.run(args);
    TestService bean = applicationContext.getBean(TestService.class);
    String response = bean.sayHello();
    System.out.println(response);

最终输出如下:

2019-12-29 15:37:35.938  INFO 25336 --- [           main] com.wakzz.autowire.proxy.HelloProxy      : 调用代理方法, method: sayHello
    hello world