使用FactoryBean和JDK代理实现动态注册接口Bean-526互联

一、介绍
二、步骤
三、实现效果
四、源码

一、介绍

本文将介绍如何通过FactoryBean和JDK动态代理实现动态注册接口Bean，做到无具体实现的类也能调用方法，类似openFeign中的接口调用和mybatis中的Mapper，下面将使用openFeign的示例讲解实现过程。

二、步骤

创建注解类

EnableFeignClients.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    String[] basePackages() default {};
}

FeignClient.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface FeignClient {
    String value();
}

测试接口类RemoteUserService.java

@FeignClient(value = "user-server")
public interface RemoteUserService {
    @GetMapping("/getUser")
    Object getUser(@RequestParam String id);
}

创建FeignClientFactoryBean.java，通过jdk动态代理获取代理对象

public class FeignClientFactoryBean implements FactoryBean<Object> {
    private Class<?> type;

    public FeignClientFactoryBean(Class<?> type) {
        this.type = type;
    }

    @Override
    public Object getObject() {
        return this.getTarget();
    }

    /**
     * 通过动态代理获取代理对象（重要）
     * @param <T>
     * @return
     */
    <T> T getTarget() {
        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[]{type}, new FeignProxy());
    }

    @Override
    public Class<?> getObjectType() {
        return type;
    }
}

创建代理类FeignProxy.java，具体的方法执行都在这个类

public class FeignProxy implements InvocationHandler {
    private static final Logger log = LoggerFactory.getLogger(FeignProxy.class);

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("类{}，执行了{}方法，参数={}", method.getDeclaringClass().getName(), method.getName(),args);
        return "张三";
    }
}

创建注册所有的FeignClient的类FeignClientsRegistrar.java

伪代码：

获取所有的包路径，从EnableFeignClients注解上的属性以及启动类所在的包获得
通过ClassPathScanningCandidateComponentProvider类扫码所有带FeignClient注解的类
遍历所有获取到带FeignClient类并进行通过BeanDefinitionRegistry进行bean注册
注册这类的bean是通过FactoryBean去创建对象

@Configuration
public class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
    private ResourceLoader resourceLoader;
    private Environment environment;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet();
        Set<String> basePackages = getBasePackage(metadata);

        for (String basePackage : basePackages) {
            ClassPathScanningCandidateComponentProvider scanner = this.createScanner();
            scanner.setResourceLoader(this.resourceLoader);
            scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));

            // 添加所有扫码到的类
            candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
        }

        for (BeanDefinition beanDefinition : candidateComponents) {
            if (beanDefinition instanceof AnnotatedBeanDefinition) {
                AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) beanDefinition;
                AnnotationMetadata annotationMetadata = annotatedBeanDefinition.getMetadata();
                // 注册bean
                registerFeignClient(registry, annotationMetadata);
            }
        }
    }

    /**
     * 注册bean
     *
     * @param registry
     * @param annotationMetadata
     */
    private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata) {
        // 获取class名称
        String className = annotationMetadata.getClassName();
        Class<?> clazz = null;
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        FeignClientFactoryBean factoryBean = new FeignClientFactoryBean(clazz);
        BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, new Supplier() {
            @Override
            public Object get() {
                return factoryBean.getObject();
            }
        });
        registry.registerBeanDefinition(clazz.getName(), definition.getBeanDefinition());
    }

    /**
     * 创建类路径扫描器
     *
     * @return
     */
    private ClassPathScanningCandidateComponentProvider createScanner() {
        return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
            protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
                boolean isCandidate = false;
                // isIndependent是顶级接口，isAnnotation是注解类
                if (beanDefinition.getMetadata().isIndependent() && !beanDefinition.getMetadata().isAnnotation()) {
                    isCandidate = true;
                }

                return isCandidate;
            }
        };
    }


    /**
     * 获取
     *
     * @param metadata
     * @return
     */
    private Set<String> getBasePackage(AnnotationMetadata metadata) {
        Set<String> basePackage = new HashSet<>();

        // 获取启动类的包路径
        String bootstrapClassName = metadata.getClassName();
        String bootstrapClassPackage = bootstrapClassName.substring(0, bootstrapClassName.lastIndexOf("."));
        basePackage.add(bootstrapClassPackage);

        // 获取注解上面的包路径
        Map<String, Object> attributes = metadata.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());
        String[] basePackages = (String[]) attributes.get("basePackages");
        basePackage.addAll(Arrays.asList(basePackages));

        return basePackage;
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
}