创建核心代码模块

概述

本模块依托于 Spring Boot 提供的 Spring Factories 扩展机制，该机制为 Spring Boot Starter 实现的基础，需要额外讲解。因与主线无关此处不做额外扩展。

POM

创建一个名为 spring-cloud-alibaba-dubbo-core 的模块，其父工程为我们的工程项目 spring-cloud-alibaba-dubbo-parent

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.cmcc</groupId>
            <artifactId>spring-cloud-alibaba-dubbo-parent</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </parent>
    
        <artifactId>spring-cloud-alibaba-dubbo-core</artifactId>
        <url>http://www.cmcc.com</url>
    
        <dependencies>
            <!-- Spring Cloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
                <scope>provided</scope>
            </dependency>
    
            <!-- Dubbo -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.boot</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </project>

创建核心工具类

在 com.alibaba.dubbo.config.spring.beans.factory.annotation 包下创建一个名为 FeignClientToDubboProviderBeanPostProcessor 的工具类

注：包名不可修改，注释中已有详细说明

    package com.alibaba.dubbo.config.spring.beans.factory.annotation;
    
    import com.alibaba.dubbo.common.logger.Logger;
    import com.alibaba.dubbo.common.logger.LoggerFactory;
    import com.alibaba.dubbo.config.annotation.Service;
    import com.alibaba.dubbo.config.spring.ServiceBean;
    import com.alibaba.dubbo.config.spring.context.annotation.DubboClassPathBeanDefinitionScanner;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.MutablePropertyValues;
    import org.springframework.beans.factory.BeanClassLoaderAware;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.BeanDefinitionHolder;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.config.RuntimeBeanReference;
    import org.springframework.beans.factory.config.SingletonBeanRegistry;
    import org.springframework.beans.factory.support.AbstractBeanDefinition;
    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.beans.factory.support.BeanNameGenerator;
    import org.springframework.beans.factory.support.ManagedList;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.context.EnvironmentAware;
    import org.springframework.context.ResourceLoaderAware;
    import org.springframework.context.annotation.AnnotationBeanNameGenerator;
    import org.springframework.context.annotation.AnnotationConfigUtils;
    import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
    import org.springframework.context.annotation.ConfigurationClassPostProcessor;
    import org.springframework.core.env.Environment;
    import org.springframework.core.io.ResourceLoader;
    import org.springframework.core.type.filter.AnnotationTypeFilter;
    import org.springframework.util.Assert;
    import org.springframework.util.ClassUtils;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.ObjectUtils;
    import org.springframework.util.StringUtils;
    
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.LinkedHashSet;
    import java.util.List;
    import java.util.Set;
    
    import static com.alibaba.dubbo.config.spring.util.ObjectUtils.of;
    import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
    import static org.springframework.context.annotation.AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR;
    import static org.springframework.core.annotation.AnnotationUtils.findAnnotation;
    import static org.springframework.util.ClassUtils.resolveClassName;
    
    /**
     * 不要自定义该类所在包名，本项目依赖的是 Dubbo 2.6.6 版本，截止代码创建日期 2019/3/12 ，Dubbo 的最新版本为 2.7.0
     * 但由于 2.7.0 版本的 Dubbo 有个配置与 Eureka 的端点检查配置注入时冲突，暂时无法解决（按照官方 issues 做了，也没啥卵用，故降级到当前版本），该 Bug 官方说法是在 2.7.1 版本中修复
     * 自 Dubbo 2.7.0 版本开始，所有包名更改为 org.apache.dubbo.* ，原 com.alibaba.dubbo.* 包下的代码官方应该会停止维护了
     * 升级到 Dubbo 2.7.0 以上版本则当前包名也需要同步修改为 org.apache.dubbo.*
     * <p>Title: FeignClientToDubboProviderBeanPostProcessor</p>
     * <p>Description: </p>
     *
     * @author cmcc
     * @version 1.0.0
     * @date 2019/3/12 12:13
     */
    public class FeignClientToDubboProviderBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,
            ResourceLoaderAware, BeanClassLoaderAware {
    
        private static final String SEPARATOR = ":";
    
        private final Logger logger = LoggerFactory.getLogger(getClass());
    
        private final Set<String> packagesToScan;
    
        private Environment environment;
    
        private ResourceLoader resourceLoader;
    
        private ClassLoader classLoader;
    
        private Service defaultService;
    
        public FeignClientToDubboProviderBeanPostProcessor(String... packagesToScan) {
            this(Arrays.asList(packagesToScan));
        }
    
        public FeignClientToDubboProviderBeanPostProcessor(Collection<String> packagesToScan) {
            this(new LinkedHashSet<String>(packagesToScan));
        }
    
        public FeignClientToDubboProviderBeanPostProcessor(Set<String> packagesToScan) {
            this.packagesToScan = packagesToScan;
            @Service
            final class DefaultServiceClass {
            }
            ;
            this.defaultService = DefaultServiceClass.class.getAnnotation(Service.class);
        }
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    
            Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);
    
            if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
                registerServiceBeans(resolvedPackagesToScan, registry);
            } else {
                if (logger.isWarnEnabled()) {
                    logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
                }
            }
    
        }
    
    
        /**
         * Registers Beans whose classes was annotated {@link FeignClient}
         *
         * @param packagesToScan The base packages to scan
         * @param registry       {@link BeanDefinitionRegistry}
         */
        private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
    
            DubboClassPathBeanDefinitionScanner scanner =
                    new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
    
            BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    
            scanner.setBeanNameGenerator(beanNameGenerator);
    
            scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class, true, true));
    
            for (String packageToScan : packagesToScan) {
    
                // Registers @Service Bean first
                scanner.scan(packageToScan);
    
                // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
                Set<BeanDefinitionHolder> beanDefinitionHolders =
                        findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
    
                if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
    
                    for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                        registerServiceBean(beanDefinitionHolder, registry, scanner);
                    }
    
                    if (logger.isInfoEnabled()) {
                        logger.info(beanDefinitionHolders.size() + " annotated Dubbo's @Service Components { " +
                                beanDefinitionHolders +
                                " } were scanned under package[" + packageToScan + "]");
                    }
    
                } else {
    
                    if (logger.isWarnEnabled()) {
                        logger.warn("No Spring Bean annotating Dubbo's @Service was found under package["
                                + packageToScan + "]");
                    }
    
                }
    
            }
    
        }
    
        /**
         * It'd better to use BeanNameGenerator instance that should reference
         * {@link ConfigurationClassPostProcessor#componentScanBeanNameGenerator},
         * thus it maybe a potential problem on bean name generation.
         *
         * @param registry {@link BeanDefinitionRegistry}
         * @return {@link BeanNameGenerator} instance
         * @see SingletonBeanRegistry
         * @see AnnotationConfigUtils#CONFIGURATION_BEAN_NAME_GENERATOR
         * @see ConfigurationClassPostProcessor#processConfigBeanDefinitions
         * @since 2.5.8
         */
        private BeanNameGenerator resolveBeanNameGenerator(BeanDefinitionRegistry registry) {
    
            BeanNameGenerator beanNameGenerator = null;
    
            if (registry instanceof SingletonBeanRegistry) {
                SingletonBeanRegistry singletonBeanRegistry = SingletonBeanRegistry.class.cast(registry);
                beanNameGenerator = (BeanNameGenerator) singletonBeanRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
            }
    
            if (beanNameGenerator == null) {
    
                if (logger.isInfoEnabled()) {
    
                    logger.info("BeanNameGenerator bean can't be found in BeanFactory with name ["
                            + CONFIGURATION_BEAN_NAME_GENERATOR + "]");
                    logger.info("BeanNameGenerator will be a instance of " +
                            AnnotationBeanNameGenerator.class.getName() +
                            " , it maybe a potential problem on bean name generation.");
                }
    
                beanNameGenerator = new AnnotationBeanNameGenerator();
    
            }
    
            return beanNameGenerator;
    
        }
    
        /**
         * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders} whose bean type annotated
         * {@link Service} Annotation.
         *
         * @param scanner       {@link ClassPathBeanDefinitionScanner}
         * @param packageToScan pachage to scan
         * @param registry      {@link BeanDefinitionRegistry}
         * @return non-null
         * @since 2.5.8
         */
        private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(
                ClassPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry,
                BeanNameGenerator beanNameGenerator) {
    
            Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    
            Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    
            for (BeanDefinition beanDefinition : beanDefinitions) {
    
                String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
                BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
                beanDefinitionHolders.add(beanDefinitionHolder);
    
            }
    
            return beanDefinitionHolders;
    
        }
    
        /**
         * Registers {@link ServiceBean} from new annotated {@link Service} {@link BeanDefinition}
         *
         * @param beanDefinitionHolder
         * @param registry
         * @param scanner
         * @see ServiceBean
         * @see BeanDefinition
         */
        private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
                                         DubboClassPathBeanDefinitionScanner scanner) {
    
            Class<?> beanClass = resolveClass(beanDefinitionHolder);
    
            Service service = findAnnotation(beanClass, Service.class);
            if (null == service) {
                service = this.defaultService;
            }
    
            Class<?> interfaceClass = resolveServiceInterfaceClass(beanClass, service);
    
            String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();
    
            AbstractBeanDefinition serviceBeanDefinition =
                    buildServiceBeanDefinition(service, interfaceClass, annotatedServiceBeanName);
    
            // ServiceBean Bean name
            String beanName = generateServiceBeanName(service, interfaceClass, annotatedServiceBeanName);
    
            if (scanner.checkCandidate(beanName, serviceBeanDefinition)) { // check duplicated candidate bean
                registry.registerBeanDefinition(beanName, serviceBeanDefinition);
    
                if (logger.isInfoEnabled()) {
                    logger.warn("The BeanDefinition[" + serviceBeanDefinition +
                            "] of ServiceBean has been registered with name : " + beanName);
                }
    
            } else {
    
                if (logger.isWarnEnabled()) {
                    logger.warn("The Duplicated BeanDefinition[" + serviceBeanDefinition +
                            "] of ServiceBean[ bean name : " + beanName +
                            "] was be found , Did @DubboComponentScan scan to same package in many times?");
                }
    
            }
    
        }
    
        /**
         * Generates the bean name of {@link ServiceBean}
         *
         * @param service
         * @param interfaceClass           the class of interface annotated {@link Service}
         * @param annotatedServiceBeanName the bean name of annotated {@link Service}
         * @return ServiceBean@interfaceClassName#annotatedServiceBeanName
         * @since 2.5.9
         */
        private String generateServiceBeanName(Service service, Class<?> interfaceClass, String annotatedServiceBeanName) {
    
            StringBuilder beanNameBuilder = new StringBuilder(ServiceBean.class.getSimpleName());
    
            beanNameBuilder.append(SEPARATOR).append(annotatedServiceBeanName);
    
            String interfaceClassName = interfaceClass.getName();
    
            beanNameBuilder.append(SEPARATOR).append(interfaceClassName);
    
            String version = service.version();
    
            if (StringUtils.hasText(version)) {
                beanNameBuilder.append(SEPARATOR).append(version);
            }
    
            String group = service.group();
    
            if (StringUtils.hasText(group)) {
                beanNameBuilder.append(SEPARATOR).append(group);
            }
    
            return beanNameBuilder.toString();
    
        }
    
        private Class<?> resolveServiceInterfaceClass(Class<?> annotatedServiceBeanClass, Service service) {
    
            Class<?> interfaceClass = service.interfaceClass();
    
            if (void.class.equals(interfaceClass)) {
    
                interfaceClass = null;
    
                String interfaceClassName = service.interfaceName();
    
                if (StringUtils.hasText(interfaceClassName)) {
                    if (ClassUtils.isPresent(interfaceClassName, classLoader)) {
                        interfaceClass = resolveClassName(interfaceClassName, classLoader);
                    }
                }
    
            }
    
            if (interfaceClass == null) {
    
                Class<?>[] allInterfaces = annotatedServiceBeanClass.getInterfaces();
    
                if (allInterfaces.length > 0) {
                    interfaceClass = allInterfaces[0];
                }
    
            }
    
            Assert.notNull(interfaceClass,
                    "@Service interfaceClass() or interfaceName() or interface class must be present!");
    
            Assert.isTrue(interfaceClass.isInterface(),
                    "The type that was annotated @Service is not an interface!");
    
            return interfaceClass;
        }
    
        private Class<?> resolveClass(BeanDefinitionHolder beanDefinitionHolder) {
    
            BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
    
            return resolveClass(beanDefinition);
    
        }
    
        private Class<?> resolveClass(BeanDefinition beanDefinition) {
    
            String beanClassName = beanDefinition.getBeanClassName();
    
            return resolveClassName(beanClassName, classLoader);
    
        }
    
        private Set<String> resolvePackagesToScan(Set<String> packagesToScan) {
            Set<String> resolvedPackagesToScan = new LinkedHashSet<String>(packagesToScan.size());
            for (String packageToScan : packagesToScan) {
                if (StringUtils.hasText(packageToScan)) {
                    String resolvedPackageToScan = environment.resolvePlaceholders(packageToScan.trim());
                    resolvedPackagesToScan.add(resolvedPackageToScan);
                }
            }
            return resolvedPackagesToScan;
        }
    
        private AbstractBeanDefinition buildServiceBeanDefinition(Service service, Class<?> interfaceClass,
                                                                  String annotatedServiceBeanName) {
    
            BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class);
    
            AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
    
            MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
    
            String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol", "interface");
    
            propertyValues.addPropertyValues(new AnnotationPropertyValuesAdapter(service, environment, ignoreAttributeNames));
    
            // References "ref" property to annotated-@Service Bean
            addPropertyReference(builder, "ref", annotatedServiceBeanName);
            // Set interface
            builder.addPropertyValue("interface", interfaceClass.getName());
    
            /**
             * Add {@link com.alibaba.dubbo.config.ProviderConfig} Bean reference
             */
            String providerConfigBeanName = service.provider();
            if (StringUtils.hasText(providerConfigBeanName)) {
                addPropertyReference(builder, "provider", providerConfigBeanName);
            }
    
            /**
             * Add {@link com.alibaba.dubbo.config.MonitorConfig} Bean reference
             */
            String monitorConfigBeanName = service.monitor();
            if (StringUtils.hasText(monitorConfigBeanName)) {
                addPropertyReference(builder, "monitor", monitorConfigBeanName);
            }
    
            /**
             * Add {@link com.alibaba.dubbo.config.ApplicationConfig} Bean reference
             */
            String applicationConfigBeanName = service.application();
            if (StringUtils.hasText(applicationConfigBeanName)) {
                addPropertyReference(builder, "application", applicationConfigBeanName);
            }
    
            /**
             * Add {@link com.alibaba.dubbo.config.ModuleConfig} Bean reference
             */
            String moduleConfigBeanName = service.module();
            if (StringUtils.hasText(moduleConfigBeanName)) {
                addPropertyReference(builder, "module", moduleConfigBeanName);
            }
    
    
            /**
             * Add {@link com.alibaba.dubbo.config.RegistryConfig} Bean reference
             */
            String[] registryConfigBeanNames = service.registry();
    
            List<RuntimeBeanReference> registryRuntimeBeanReferences = toRuntimeBeanReferences(registryConfigBeanNames);
    
            if (!registryRuntimeBeanReferences.isEmpty()) {
                builder.addPropertyValue("registries", registryRuntimeBeanReferences);
            }
    
            /**
             * Add {@link com.alibaba.dubbo.config.ProtocolConfig} Bean reference
             */
            String[] protocolConfigBeanNames = service.protocol();
    
            List<RuntimeBeanReference> protocolRuntimeBeanReferences = toRuntimeBeanReferences(protocolConfigBeanNames);
    
            if (!protocolRuntimeBeanReferences.isEmpty()) {
                builder.addPropertyValue("protocols", protocolRuntimeBeanReferences);
            }
    
            return builder.getBeanDefinition();
    
        }
    
    
        private ManagedList<RuntimeBeanReference> toRuntimeBeanReferences(String... beanNames) {
    
            ManagedList<RuntimeBeanReference> runtimeBeanReferences = new ManagedList<RuntimeBeanReference>();
    
            if (!ObjectUtils.isEmpty(beanNames)) {
    
                for (String beanName : beanNames) {
    
                    String resolvedBeanName = environment.resolvePlaceholders(beanName);
    
                    runtimeBeanReferences.add(new RuntimeBeanReference(resolvedBeanName));
                }
    
            }
    
            return runtimeBeanReferences;
    
        }
    
        private void addPropertyReference(BeanDefinitionBuilder builder, String propertyName, String beanName) {
            String resolvedBeanName = environment.resolvePlaceholders(beanName);
            builder.addPropertyReference(propertyName, resolvedBeanName);
        }
    
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    
        }
    
        @Override
        public void setEnvironment(Environment environment) {
            this.environment = environment;
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
        }
    
        @Override
        public void setBeanClassLoader(ClassLoader classLoader) {
            this.classLoader = classLoader;
        }
    
    }

正常情况下我们都是使用 Dubbo 提供的 @Service 注解将服务注册到 Dubbo 的注册中心，现要求既能使用 RESTful 又能使用 Dubbo，故需要使用一个统一的注解 @FeignClient 处理，关键代码如下：

    /**
     * Registers Beans whose classes was annotated {@link FeignClient}
     *
     * @param packagesToScan The base packages to scan
     * @param registry       {@link BeanDefinitionRegistry}
     */
    private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
    
        DubboClassPathBeanDefinitionScanner scanner =
                new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
    
        BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    
        scanner.setBeanNameGenerator(beanNameGenerator);
    
        scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class, true, true));
    
        for (String packageToScan : packagesToScan) {
    
            // Registers @Service Bean first
            scanner.scan(packageToScan);
    
            // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
            Set<BeanDefinitionHolder> beanDefinitionHolders =
                    findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
    
            if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
    
                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    registerServiceBean(beanDefinitionHolder, registry, scanner);
                }
    
                if (logger.isInfoEnabled()) {
                    logger.info(beanDefinitionHolders.size() + " annotated Dubbo's @Service Components { " +
                            beanDefinitionHolders +
                            " } were scanned under package[" + packageToScan + "]");
                }
    
            } else {
    
                if (logger.isWarnEnabled()) {
                    logger.warn("No Spring Bean annotating Dubbo's @Service was found under package["
                            + packageToScan + "]");
                }
    
            }
    
        }
    
    }

创建 Dubbo 调用替换类

在 com.alibaba.dubbo.config.spring.beans.factory.annotation 包下创建一个名为 DubboFeignBuilder 的工具类

注：包名不可修改

    package com.alibaba.dubbo.config.spring.beans.factory.annotation;
    
    import com.alibaba.dubbo.config.annotation.Reference;
    import feign.Feign;
    import feign.Target;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.util.ReflectionUtils;
    
    public class DubboFeignBuilder extends Feign.Builder {
        @Autowired
        private ApplicationContext applicationContext;
    
        public Reference defaultReference;
        final class DefaultReferenceClass{
            @Reference(check = false) String field;
        }
    
        public DubboFeignBuilder() {
            this.defaultReference = ReflectionUtils.findField(DubboFeignBuilder.DefaultReferenceClass.class,"field").getAnnotation(Reference.class);
        }
    
    
        @Override
        public <T> T target(Target<T> target) {
            ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
                    .create(defaultReference, target.getClass().getClassLoader(), applicationContext)
                    .interfaceClass(target.type());
    
            try {
                T object = (T) beanBuilder.build().getObject();
                return object;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

正常情况下我们都是使用 Dubbo 提供的 @Reference 注解来调用 Dubbo 服务，改造后我们需要能够支持 RESRful 和 Dubbo 两种调用方式，如果项目中存在 Dubbo 依赖则使用 Dubbo 来调用服务，否则使用 RESTful 调用，关键代码如下：

    @Override
    public <T> T target(Target<T> target) {
        ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
                .create(defaultReference, target.getClass().getClassLoader(), applicationContext)
                .interfaceClass(target.type());
    
        try {
            T object = (T) beanBuilder.build().getObject();
            return object;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

创建自动配置类

利用 Spring Boot Starter 的扩展机制来制作我们自己的 Starter

    package com.cmcc.alibaba.dubbo.core;
    
    import com.alibaba.dubbo.config.AbstractConfig;
    import com.alibaba.dubbo.config.spring.beans.factory.annotation.DubboFeignBuilder;
    import com.alibaba.dubbo.config.spring.beans.factory.annotation.FeignClientToDubboProviderBeanPostProcessor;
    import feign.Feign;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.context.properties.source.ConfigurationPropertySources;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.env.Environment;
    
    import java.util.Set;
    
    import static com.alibaba.boot.dubbo.util.DubboUtils.BASE_PACKAGES_PROPERTY_NAME;
    import static com.alibaba.boot.dubbo.util.DubboUtils.DUBBO_PREFIX;
    import static java.util.Collections.emptySet;
    
    @Configuration
    @ConditionalOnProperty(prefix = DUBBO_PREFIX, name = "enabled", matchIfMissing = true, havingValue = "true")
    @ConditionalOnClass(AbstractConfig.class)
    public class SpringCloudAlibabaDubboAutoConfiguration {
        @ConditionalOnProperty(name = BASE_PACKAGES_PROPERTY_NAME)
        @ConditionalOnClass(ConfigurationPropertySources.class)
        @Bean
        public FeignClientToDubboProviderBeanPostProcessor feignClientToDubboProviderBeanPostProcessor(Environment environment) {
            Set<String> packagesToScan = environment.getProperty(BASE_PACKAGES_PROPERTY_NAME, Set.class, emptySet());
            return new FeignClientToDubboProviderBeanPostProcessor(packagesToScan);
        }
    
        @Bean
        public Feign.Builder feignDubboBuilder() {
            return new DubboFeignBuilder();
        }
    }

说明：

• @ConditionalOnProperty：触发条件，当配置文件中存在预设条件则触发当前自动配置
• @ConditionalOnClass：触发条件，当 classpath 下存在预设类则触发当前自动配置

spring.factories

在 src/main/resources/META-INF 目录下创建一个名为 spring.factories 的配置文件

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      com.cmcc.alibaba.dubbo.core.SpringCloudAlibabaDubboAutoConfiguration