// EchoService.java

public interface EchoService {

    String echo(String message);

    String plus(int a, int b);

}

// DefaultEchoService.java

@Service(version = "1.0.0", protocol = {"dubbo", "rest"})
@RestController
@Path("/")
public class DefaultEchoService implements EchoService {

    @Override
    @GetMapping(value = "/echo"
//            consumes = MediaType.APPLICATION_JSON_VALUE,
//            produces = MediaType.APPLICATION_JSON_UTF8_VALUE
    )
    @Path("/echo")
    @GET
//    @Consumes("application/json")
//    @Produces("application/json;charset=UTF-8")
    public String echo(@RequestParam @QueryParam("message") String message) {
        System.out.println(message);
        return RpcContext.getContext().getUrl() + " [echo] : " + message;
    }

    @Override
    @PostMapping("/plus")
    @Path("/plus")
    @POST
    public String plus(@RequestParam @QueryParam("a") int a, @RequestParam @QueryParam("b") int b) {
        return null;
    }

}

// DubboSpringCloudBootstrap.java

@EnableDiscoveryClient // 开启注册发现
@EnableAutoConfiguration // 开启自动配置
@EnableFeignClients // 开启 Feign Client
@RestController
public class DubboSpringCloudBootstrap {

    @Reference(version = "1.0.0")
    private EchoService echoService;

    @Autowired
    @Lazy
    private FeignEchoService feignEchoService;

    @Autowired
    @Lazy
    private DubboFeignEchoService dubboFeignEchoService;

    public static void main(String[] args) {
        new SpringApplicationBuilder(DubboSpringCloudBootstrap.class)
                .run(args);
    }

}

// DubboSpringCloudBootstrap.java

@Bean
public ApplicationRunner applicationRunner() {
    return arguments -> {
        // Dubbo Service call
        System.out.println(echoService.echo("mercyblitz"));
        // Spring Cloud Open Feign REST Call
        System.out.println(feignEchoService.echo("mercyblitz"));
        // Spring Cloud Open Feign REST Call (Dubbo Transported)
        System.out.println(dubboFeignEchoService.echo("mercyblitz"));
    };
}

// DubboSpringCloudBootstrap.java

@GetMapping(value = "/dubbo/call/echo")
public String dubboEcho(@RequestParam("message") String message) {
    return echoService.echo(message);
}

@GetMapping(value = "/feign/call/echo")
public String feignEcho(@RequestParam("message") String message) {
    return feignEchoService.echo(message);
}

@GetMapping(value = "/feign-dubbo/call/echo")
public String feignDubboEcho(@RequestParam("message") String message) {
    return dubboFeignEchoService.echo(message);
}

// DubboTransported.java

/**
 * {@link DubboTransported @DubboTransported} annotation indicates that the traditional Spring Cloud Service-to-Service call is transported
 * by Dubbo under the hood, there are two main scenarios:
 * <ol>
 * <li>{@link FeignClient @FeignClient} annotated classes:
 * <ul>
 * If {@link DubboTransported @DubboTransported} annotated classes, the invocation of all methods of
 * {@link FeignClient @FeignClient} annotated classes.
 * </ul>
 * <ul>
 * If {@link DubboTransported @DubboTransported} annotated methods of {@link FeignClient @FeignClient} annotated classes.
 * </ul>
 * </li>
 * <li>{@link LoadBalanced @LoadBalanced} {@link RestTemplate} annotated field, method and parameters</li>
 * </ol>
 * <p>
 *
 * @see FeignClient
 * @see LoadBalanced
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) // 支持类、方法
@Documented
public @interface DubboTransported {

    /**
     * The protocol of Dubbo transport whose value could be used the placeholder "dubbo.transport.protocol"
     *
     * 使用的 Dubbo 协议，默认为 "dubbo"
     *
     * @return the default protocol is "dubbo"
     */
    String protocol() default "${dubbo.transport.protocol:dubbo}";

    /**
     * The cluster of Dubbo transport whose value could be used the placeholder "dubbo.transport.cluster"
     *
     * 使用的集群容错方式，默认为 "failover"
     *
     * @return the default protocol is "failover"
     */
    String cluster() default "${dubbo.transport.cluster:failover}";

}

// DubboMetadataAutoConfiguration.java

@Configuration
@Import(DubboServiceMetadataRepository.class) // 创建了 DubboServiceMetadataRepository Bean 对象
public class DubboMetadataAutoConfiguration {

    @Bean // 创建了 NacosMetadataConfigService Bean 对象
    @ConditionalOnBean(NacosConfigProperties.class)
    public MetadataConfigService metadataConfigService() {
        return new NacosMetadataConfigService();
    }

}

// DubboOpenFeignAutoConfiguration.java

@ConditionalOnClass(value = Feign.class) // 存在 Feign 类的时候，即存在 feign 依赖
@AutoConfigureAfter(FeignAutoConfiguration.class) // 在 FeignAutoConfiguration 配置类之后初始化
@Configuration
public class DubboOpenFeignAutoConfiguration {

    @Value("${spring.application.name}")
    private String currentApplicationName;

    @Bean // 创建 DubboServiceBeanMetadataResolver 对象
    @ConditionalOnMissingBean
    public MetadataResolver metadataJsonResolver(ObjectProvider<Contract> contract) {
        return new DubboServiceBeanMetadataResolver(currentApplicationName, contract);
    }

    @Bean // 创建 TargeterBeanPostProcessor 对象
    public TargeterBeanPostProcessor targeterBeanPostProcessor(Environment environment,
                                                               DubboServiceMetadataRepository dubboServiceMetadataRepository) {
        return new TargeterBeanPostProcessor(environment, dubboServiceMetadataRepository);
    }

}

// DubboRestMetadataRegistrationAutoConfiguration.java

@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true) // 要求有 "spring.cloud.service-registry.auto-registration.enabled=true" ，或者不配置。
@ConditionalOnBean(value = { // 要求存在 MetadataResolver、MetadataConfigService Bean 对象
        MetadataResolver.class,
        MetadataConfigService.class
})
@AutoConfigureAfter(value = {DubboMetadataAutoConfiguration.class}) // 在 DubboMetadataAutoConfiguration 配置类之后初始化
@Configuration
public class DubboRestMetadataRegistrationAutoConfiguration {

    /**
     * A Map to store REST metadata temporary, its' key is the special service name for a Dubbo service,
     * the value is a JSON content of JAX-RS or Spring MVC REST metadata from the annotated methods.
     *
     * Dubbo Rest Service 方法的元数据（Metadata）集合
     */
    private final Set<ServiceRestMetadata> serviceRestMetadata = new LinkedHashSet<>();

    @Autowired // 默认情况下，来自 DubboOpenFeignAutoConfiguration 注册的 DubboServiceBeanMetadataResolver Bean 对象
    private MetadataResolver metadataResolver;

    @Autowired // 默认情况下，来自 DubboMetadataAutoConfiguration 注册的 NacosMetadataConfigService Bean 对象
    private MetadataConfigService metadataConfigService;

    @EventListener(ServiceBeanExportedEvent.class)
    public void recordRestMetadata(ServiceBeanExportedEvent event) throws JsonProcessingException {
        ServiceBean serviceBean = event.getServiceBean();
        serviceRestMetadata.addAll(metadataResolver.resolveServiceRestMetadata(serviceBean));
    }

    /**
     * Pre-handle Spring Cloud application service registered:
     * <p>
     * Put <code>restMetadata</code> with the JSON format into
     * {@link Registration#getMetadata() service instances' metadata}
     * <p>
     *
     * @param event {@link InstancePreRegisteredEvent} instance
     */
    @EventListener(InstancePreRegisteredEvent.class)
    public void registerRestMetadata(InstancePreRegisteredEvent event) throws Exception {
        Registration registration = event.getRegistration();
        metadataConfigService.publishServiceRestMetadata(registration.getServiceId(), serviceRestMetadata);
    }

}

// SpringCloudRegistryFactory.java

/**
 * The Dubbo services will be registered as the specified Spring cloud applications that will not be considered
 * normal ones, but only are used to Dubbo's service discovery even if it is based on Spring Cloud Commons abstraction.
 * However, current application will be registered by other DiscoveryClientAutoConfiguration.
 *
 */
public class DubboServiceRegistrationApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // Set ApplicationContext into SpringCloudRegistryFactory before Dubbo Service Register
        SpringCloudRegistryFactory.setApplicationContext(applicationContext);
    }

}

// ServiceRestMetadata.java

public class ServiceRestMetadata {

    /**
     * 服务名
     */
    private String name;
    /**
     * Rest 方法元数据
     */
    private Set<RestMethodMetadata> meta;

    // ... 省略 setting/getting 方法
}

// RestMethodMetadata.java

public class RestMethodMetadata {

    /**
     * 方法元数据
     */
    private MethodMetadata method;
    /**
     * 请求元数据
     */
    private RequestMetadata request;
    /**
     * TODO
     */
    private Map<Integer, Collection<String>> indexToName;

    // ... 省略 setting/getting 方法
}

// ServiceRestMetadata.java

public class MethodMetadata {

    /**
     * 方法名
     */
    private String name;
    /**
     * 返回类型
     */
    private String returnType;
    /**
     * 方法参数元数据的数组
     */
    private List<MethodParameterMetadata> params;
    /**
     * 方法
     */
    @JsonIgnore // 不存储到配置中心
    private Method method;

    public MethodMetadata() {
        this.params = new LinkedList<>();
    }

    public MethodMetadata(Method method) {
        this.name = method.getName();
        // 获得返回类型
        this.returnType = ClassUtils.getName(method.getReturnType());
        // 初始化 params
        this.params = initParameters(method);
        this.method = method;
    }

    private List<MethodParameterMetadata> initParameters(Method method) {
        // 获得参数数量
        int parameterCount = method.getParameterCount();
        // 如果参数不存在，则返回空数组
        if (parameterCount < 1) {
            return Collections.emptyList();
        }
        // 创建 MethodParameterMetadata 数组
        List<MethodParameterMetadata> params = new ArrayList<>(parameterCount);
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameterCount; i++) {
            // 获得 Parameter 对象
            Parameter parameter = parameters[i];
            // 转换成 MethodParameterMetadata 对象
            MethodParameterMetadata param = toMethodParameterMetadata(i, parameter);
            // 添加到 params 中
            params.add(param);
        }
        return params;
    }

    private MethodParameterMetadata toMethodParameterMetadata(int index, Parameter parameter) {
        // 创建 MethodParameterMetadata 对象
        MethodParameterMetadata metadata = new MethodParameterMetadata();
        metadata.setIndex(index); // 方法参数的位置
        metadata.setName(parameter.getName()); // 方法参数的名字
        metadata.setType(parameter.getType().getTypeName()); // 方法参数的类型
        return metadata;
    }

    // ... 省略 setting/getting 方法
}

// MethodParameterMetadata.java

public class MethodParameterMetadata {

    /**
     * 方法参数的位置
     */
    private int index;
    /**
     * 方法参数的名字
     */
    private String name;
    /**
     * 方法参数的类型
     */
    private String type;

    // ... 省略 setting/getting 方法
}

// RequestMetadata.java

public class RequestMetadata {

    /**
     * 方法名
     */
    private String method;
    /**
     * URL 路径
     */
    private String url;

    private Map<String, Collection<String>> queries;

    private Map<String, Collection<String>> headers;

    public RequestMetadata() {
    }

    // 将 RequestTemplate 对象，转换成 RequestMetadata 对象
    public RequestMetadata(RequestTemplate requestTemplate) {
        this.method = requestTemplate.method();
        this.url = requestTemplate.url();
        this.queries = requestTemplate.queries();
        this.headers = requestTemplate.headers();
    }

    // ... 省略 setting/getting 方法
}

// DubboTransportedMethodMetadata.java

public class DubboTransportedMethodMetadata extends MethodMetadata {

    /**
     * Dubbo 协议
     */
    private String protocol;
    /**
     * Dubbo 容错策略
     */
    private String cluster;

    // ... 省略 setting/getting 方法
}

// MetadataResolver.java

/**
 * The REST metadata resolver
 */
public interface MetadataResolver {

    /**
     * Resolve the {@link ServiceRestMetadata} {@link Set set} from {@link ServiceBean}
     *
     * 解析指定 ServiceBean 的 ServiceRestMetadata 集合
     *
     * @param serviceBean {@link ServiceBean}
     * @return non-null {@link Set}
     */
    Set<ServiceRestMetadata> resolveServiceRestMetadata(ServiceBean serviceBean);

    /**
     * Resolve {@link RestMethodMetadata} {@link Set set} from {@link Class target type}
     *
     * 解析指定类的 ServiceRestMetadata 集合
     *
     * @param targetType {@link Class target type}
     * @return non-null {@link Set}
     */
    Set<RestMethodMetadata> resolveMethodRestMetadata(Class<?> targetType);

}

// DubboServiceBeanMetadataResolver.java

/**
 * The metadata resolver for {@link Feign} for {@link ServiceBean Dubbo Service Bean} in the provider side.
 */

// DubboServiceBeanMetadataResolver.java

private static final String[] CONTRACT_CLASS_NAMES = {
        "feign.jaxrs2.JAXRS2Contract",
        "org.springframework.cloud.openfeign.support.SpringMvcContract",
};

/**
 * 当前应用名
 *
 * 不过，目前暂时并未用该参数
 */
private final String currentApplicationName;
/**
 * 当前类加载器
 */
private ClassLoader classLoader;
private final ObjectProvider<Contract> contract;

/**
 * Feign Contract 数组
 *
 * https://www.jianshu.com/p/6582f8319f72
 */
private Collection<Contract> contracts;

public DubboServiceBeanMetadataResolver(String currentApplicationName, ObjectProvider<Contract> contract) {
    this.currentApplicationName = currentApplicationName;
    this.contract = contract;
}

// DubboServiceBeanMetadataResolver.java

@Override
public void afterSingletonsInstantiated() {
    // <1> 创建 Feign Contract 数组
    LinkedList<Contract> contracts = new LinkedList<>();

    // Add injected Contract if available, for example SpringMvcContract Bean under Spring Cloud Open Feign
    // <2.1> 如果 contract 存在，则添加到 contracts 中
    contract.ifAvailable(contracts::add);

    // <2.2> 遍历 CONTRACT_CLASS_NAMES 数组，创建对应的 Contract 对象，添加到 contracts 中
    Stream.of(CONTRACT_CLASS_NAMES)
            .filter(this::isClassPresent) // filter the existed classes
            .map(this::loadContractClass) // load Contract Class
            .map(this::createContract)    // create instance by the specified class
            .forEach(contracts::add);     // add the Contract instance into contracts

    // <3> 赋值给 contracts 中
    this.contracts = Collections.unmodifiableCollection(contracts);
}

// DubboServiceBeanMetadataResolver.java

@Override
public Set<RestMethodMetadata> resolveMethodRestMetadata(Class<?> targetType) {
    // <1> 获得 Method 集合
    List<Method> feignContractMethods = selectFeignContractMethods(targetType);
    // <2> 转换成 RestMethodMetadata 集合
    return contracts.stream() // 遍历 contracts 数组
            .map(contract -> contract.parseAndValidatateMetadata(targetType)) // <2.1> 返回目标类型的 Feign MethodMetadata 数组
            .flatMap(Collection::stream)
            .map(methodMetadata -> resolveMethodRestMetadata(methodMetadata, targetType, feignContractMethods)) // <2.2> 将 Feign MethodMetadata 转换成 RestMethodMetadata 对象
            .collect(Collectors.toSet()); // 转换成 Set
}

// DubboServiceBeanMetadataResolver.java

@Override
public Set<ServiceRestMetadata> resolveServiceRestMetadata(ServiceBean serviceBean) {
    // <1.1> 获得应用的 Bean 对象
    Object bean = serviceBean.getRef();
    // <1.2> 获得 Bean 类型
    Class<?> beanType = bean.getClass();
    // <1.3> 解析 Bean 类型对应的 RestMethodMetadata 集合
    Set<RestMethodMetadata> methodRestMetadata = resolveMethodRestMetadata(beanType);

    // <2.1> 创建 ServiceRestMetadata 数组
    Set<ServiceRestMetadata> serviceRestMetadata = new LinkedHashSet<>();
    // <2.2> 获得 ServiceBean 暴露的 URL 集合
    List<URL> urls = serviceBean.getExportedUrls();
    // <2.3> 遍历 URL 集合，将 RestMethodMetadata 集合，封装成 ServiceRestMetadata 对象，然后添加到 serviceRestMetadata 中，最后返回。
    urls.stream()
            .map(SpringCloudRegistry::getServiceName)
            .forEach(serviceName -> {
                ServiceRestMetadata metadata = new ServiceRestMetadata();
                metadata.setName(serviceName);
                metadata.setMeta(methodRestMetadata);
                serviceRestMetadata.add(metadata);
            });
    return serviceRestMetadata;
}

// DubboTransportedMethodMetadataResolver.java

public Map<DubboTransportedMethodMetadata, RequestMetadata> resolve(Class<?> targetType) {
    // <1> 获得指定类的 DubboTransportedMethodMetadata 集合
    Set<DubboTransportedMethodMetadata> dubboTransportedMethodMetadataSet = resolveDubboTransportedMethodMetadataSet(targetType);
    // <2> 获得指定类的 RequestMetadata 映射。其中，KEY 为 configKey
    Map<String, RequestMetadata> requestMetadataMap = resolveRequestMetadataMap(targetType);
    // <3> 转换成 DubboTransportedMethodMetadata 和 RequestMetadata 的映射
    return dubboTransportedMethodMetadataSet
            .stream()
            .collect(Collectors.toMap(methodMetadata -> methodMetadata, methodMetadata ->
                    requestMetadataMap.get(Feign.configKey(targetType, methodMetadata.getMethod()))
            ));
}

// MetadataConfigService.java

public interface MetadataConfigService {

    /**
     * 发布指定服务的 Rest 元数据
     *
     * @param serviceName 服务名
     * @param serviceRestMetadata ServiceRestMetadata 集合
     */
    void publishServiceRestMetadata(String serviceName, Set<ServiceRestMetadata> serviceRestMetadata);

    /**
     * 获得指定服务的 Rest 元数据
     *
     * @param serviceName 服务名
     * @return ServiceRestMetadata 集合
     */
    Set<ServiceRestMetadata> getServiceRestMetadata(String serviceName);

}

// NacosMetadataConfigService.java

/**
 * ObjectMapper ，使用 Jackson 序列化和反序列化
 */
private final ObjectMapper objectMapper = new ObjectMapper();

/**
 * NacosConfigProperties 对象，用于获得 {@link #configService}
 */
@Autowired
private NacosConfigProperties nacosConfigProperties;

private ConfigService configService;

@PostConstruct
public void init() {
    // 初始化 configService 属性
    this.configService = nacosConfigProperties.configServiceInstance();
    // 开启 JSON 格式化
    this.objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
}

// NacosMetadataConfigService.java

@Override
public void publishServiceRestMetadata(String serviceName, Set<ServiceRestMetadata> serviceRestMetadata) {
    // 获得 Nacos dataId ①
    String dataId = getServiceRestMetadataDataId(serviceName);
    // 将 ServiceRestMetadata 集合序列化成 json 字符串 ②
    String json = writeValueAsString(serviceRestMetadata);
    // 写入到 Nacos 配置中心
    try {
        configService.publishConfig(dataId, DEFAULT_GROUP, json);
    } catch (NacosException e) {
        throw new RuntimeException(e);
    }
}

/**
 * Get the data Id of service rest metadata
 */
private static String getServiceRestMetadataDataId(String serviceName) { // ①
    return "metadata:rest:" + serviceName + ".json";
}

private String writeValueAsString(Object object) { // ②
    String content;
    try {
        content = objectMapper.writeValueAsString(object);
    } catch (JsonProcessingException e) {
        throw new IllegalArgumentException(e);
    }
    return content;
}

// NacosMetadataConfigService.java

@Override
public Set<ServiceRestMetadata> getServiceRestMetadata(String serviceName) {
    Set<ServiceRestMetadata> metadata;
    // 获得 Nacos dataId
    String dataId = getServiceRestMetadataDataId(serviceName);
    try {
        // 从 Nacos 配置中心，读取 json 字符串
        String json = configService.getConfig(dataId, DEFAULT_GROUP, 1000 * 3);
        // 将 json 字符串，反序列化成 ServiceRestMetadata 集合
        metadata = objectMapper.readValue(json, TypeFactory.defaultInstance().constructCollectionType(LinkedHashSet.class, ServiceRestMetadata.class));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return metadata;
}

// DubboServiceMetadataRepository.java

/**
 * RequestMetadata 和 ReferenceBean 的映射
 *
 * Key is application name
 * Value is  Map<RequestMetadata, ReferenceBean<GenericService>>
 */
private Map<String, Map<RequestMetadata, ReferenceBean<GenericService>>> referenceBeansRepository = new HashMap<>();

/**
 * RequestMetadata 和 MethodMetadata 的映射
 *
 * Key is application name
 */
private Map<String, Map<RequestMetadata, MethodMetadata>> methodMetadataRepository = new HashMap<>();

@Autowired
private MetadataConfigService metadataConfigService;

// DubboServiceMetadataRepository.java

public void updateMetadata(String serviceName) {
    // <1.1> 获得 serviceName 对应的 RequestMetadata 和 ReferenceBean 的映射
    Map<RequestMetadata, ReferenceBean<GenericService>> genericServicesMap = referenceBeansRepository.computeIfAbsent(serviceName, k -> new HashMap<>());
    // <1.2> 获得 serviceName 对应的 RequestMetadata 和 MethodMetadata 的映射
    Map<RequestMetadata, MethodMetadata> methodMetadataMap = methodMetadataRepository.computeIfAbsent(serviceName, k -> new HashMap<>());
    // <1.3> 获得 serviceName 对应的  ServiceRestMetadata 集合
    Set<ServiceRestMetadata> serviceRestMetadataSet = metadataConfigService.getServiceRestMetadata(serviceName);

    // <2> 遍历 ServiceRestMetadata 集合，创建对应的 ReferenceBean ，获得对应的 MethodMetadata 对象
    for (ServiceRestMetadata serviceRestMetadata : serviceRestMetadataSet) {
        // <2.1> 创建对应的 ReferenceBean
        ReferenceBean<GenericService> referenceBean = adaptReferenceBean(serviceRestMetadata);
        // <2.2> 遍历 RestMethodMetadata 集合，添加到 genericServicesMap 和 methodMetadataMap 中，进行缓存
        serviceRestMetadata.getMeta().forEach(restMethodMetadata -> {
            RequestMetadata requestMetadata = restMethodMetadata.getRequest();
            genericServicesMap.put(requestMetadata, referenceBean);
            methodMetadataMap.put(requestMetadata, restMethodMetadata.getMethod());
        });
    }
}

public ReferenceBean<GenericService> getReferenceBean(String serviceName, RequestMetadata requestMetadata) {
    return getReferenceBeansMap(serviceName).get(requestMetadata);
}

private Map<RequestMetadata, ReferenceBean<GenericService>> getReferenceBeansMap(String serviceName) {
    return referenceBeansRepository.getOrDefault(serviceName, Collections.emptyMap());
}

// DubboServiceMetadataRepository.java

public MethodMetadata getMethodMetadata(String serviceName, RequestMetadata requestMetadata) {
    return getMethodMetadataMap(serviceName).get(requestMetadata);
}

private Map<RequestMetadata, MethodMetadata> getMethodMetadataMap(String serviceName) {
    return methodMetadataRepository.getOrDefault(serviceName, Collections.emptyMap());
}

// TargeterBeanPostProcessor.java

public class TargeterBeanPostProcessor implements BeanPostProcessor, BeanClassLoaderAware {

    private static final String TARGETER_CLASS_NAME = "org.springframework.cloud.openfeign.Targeter";

    private final Environment environment;

    private final DubboServiceMetadataRepository dubboServiceMetadataRepository;

    private ClassLoader classLoader;

    public TargeterBeanPostProcessor(Environment environment, DubboServiceMetadataRepository dubboServiceMetadataRepository) {
        this.environment = environment;
        this.dubboServiceMetadataRepository = dubboServiceMetadataRepository;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        // <1> 获得 Bean 的类
        Class<?> beanClass = ClassUtils.getUserClass(bean.getClass());
        // <2> 获得 openfeign Targeter 接口
        Class<?> targetClass = ClassUtils.resolveClassName(TARGETER_CLASS_NAME, classLoader);
        // <3> 如果实现 openfeign Targeter 接口，则创建动态代理
        if (targetClass.isAssignableFrom(beanClass)) {
            return Proxy.newProxyInstance(classLoader, new Class[]{targetClass},
                    new TargeterInvocationHandler(bean, environment, dubboServiceMetadataRepository));
        }
        return bean;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

}

// TargeterInvocationHandler.java

class TargeterInvocationHandler implements InvocationHandler {

    private final Object bean;

    private final Environment environment;

    private final DubboServiceMetadataRepository dubboServiceMetadataRepository;

    TargeterInvocationHandler(Object bean, Environment environment,
                              DubboServiceMetadataRepository dubboServiceMetadataRepository) {
        this.bean = bean;
        this.environment = environment;
        this.dubboServiceMetadataRepository = dubboServiceMetadataRepository;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /**
         * args[0]: FeignClientFactoryBean factory
         * args[1]: Feign.Builder feign
         * args[2]: FeignContext context
         * args[3]: Target.HardCodedTarget<T> target
         */
        FeignContext feignContext = cast(args[2]);
        Target.HardCodedTarget<?> target = cast(args[3]);

        // <1> 先调用原有 target 方法，返回默认的代理对象
        // Execute Targeter#target method first
        method.setAccessible(true);
        // Get the default proxy object
        Object defaultProxy = method.invoke(bean, args);
        // Create Dubbo Proxy if required
        // 如果符合创建 Dubbo 代理对象，则创建 Dubbo 代理对象。
        // 否则，使用默认的 defaultProxy 代理
        return createDubboProxyIfRequired(feignContext, target, defaultProxy);
    }

    // ... 省略下面要讲解的方法
}

// TargeterInvocationHandler.java

private Object createDubboProxyIfRequired(FeignContext feignContext, Target target, Object defaultProxy) {
    // <1> 尝试创建 DubboInvocationHandler
    DubboInvocationHandler dubboInvocationHandler = createDubboInvocationHandler(feignContext, target, defaultProxy);
    // <2.1> 如果未创建成功，说明不符合条件，则返回默认的 defaultProxy 代理
    if (dubboInvocationHandler == null) {
        return defaultProxy;
    }
    // <2.2> 如果创建成功，说明符合条件，则创建使用 dubboInvocationHandler 的动态代理
    return Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, dubboInvocationHandler);
}

// TargeterInvocationHandler.java

private DubboInvocationHandler createDubboInvocationHandler(FeignContext feignContext, Target target, Object defaultFeignClientProxy) {
    // Service name equals @FeignClient.name()
    String serviceName = target.name();
    Class<?> targetType = target.type();

    // Get Contract Bean from FeignContext
    // <1.1> 获得 Feign Contract
    Contract contract = feignContext.getInstance(serviceName, Contract.class);
    // <1.2> 创建 DubboTransportedMethodMetadataResolver 对象
    DubboTransportedMethodMetadataResolver resolver = new DubboTransportedMethodMetadataResolver(environment, contract);
    // <1.3> 解析指定类，获得其 DubboTransportedMethodMetadata 和 RequestMetadata 的映射
    Map<DubboTransportedMethodMetadata, RequestMetadata> methodRequestMetadataMap = resolver.resolve(targetType);
    // <1.4> 如果为空，则返回，说明不符合条件
    if (methodRequestMetadataMap.isEmpty()) { // @DubboTransported method was not found
        return null;
    }

    // Update Metadata
    // <2> 初始化指定 `serviceName` 的元数据。此处，会从配置中心，获得元数据
    dubboServiceMetadataRepository.updateMetadata(serviceName);

    Map<Method, org.springframework.cloud.alibaba.dubbo.metadata.MethodMetadata> methodMetadataMap = new HashMap<>();
    Map<Method, GenericService> genericServicesMap = new HashMap<>();
    // <3> 遍历 methodRequestMetadataMap 集合，初始化其 GenericService
    methodRequestMetadataMap.forEach((dubboTransportedMethodMetadata, requestMetadata) -> {
        // <3.1.1> 获得 ReferenceBean 对象，并初始化其属性
        ReferenceBean<GenericService> referenceBean = dubboServiceMetadataRepository.getReferenceBean(serviceName, requestMetadata);
        referenceBean.setProtocol(dubboTransportedMethodMetadata.getProtocol());
        referenceBean.setCluster(dubboTransportedMethodMetadata.getCluster());
        // <3.1.2> 添加到 genericServicesMap 中
        genericServicesMap.put(dubboTransportedMethodMetadata.getMethod(), referenceBean.get());
        // <3.2.1> 获得 MethodMetadata 对象
        org.springframework.cloud.alibaba.dubbo.metadata.MethodMetadata methodMetadata = dubboServiceMetadataRepository.getMethodMetadata(serviceName, requestMetadata);
        // <3.2.2> 添加到 methodMetadataMap 中
        methodMetadataMap.put(dubboTransportedMethodMetadata.getMethod(), methodMetadata);
    });

    // <4.1> 获得默认的 defaultFeignClientProxy 中，默认的 InvocationHandler 对象
    InvocationHandler defaultFeignClientInvocationHandler = Proxy.getInvocationHandler(defaultFeignClientProxy);
    // <4.2> 创建 DubboInvocationHandler 对象
    return new DubboInvocationHandler(genericServicesMap, methodMetadataMap, defaultFeignClientInvocationHandler);
}

// DubboInvocationHandler.java

public class DubboInvocationHandler implements InvocationHandler {

    private final Map<Method, GenericService> genericServicesMap;

    private final Map<Method, MethodMetadata> methodMetadata;

    private final InvocationHandler defaultInvocationHandler;

    public DubboInvocationHandler(Map<Method, GenericService> genericServicesMap,
                                  Map<Method, MethodMetadata> methodMetadata,
                                  InvocationHandler defaultInvocationHandler) {
        this.genericServicesMap = genericServicesMap;
        this.methodMetadata = methodMetadata;
        this.defaultInvocationHandler = defaultInvocationHandler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 获得 GenericService 对象
        GenericService genericService = genericServicesMap.get(method);
        // 获得 MethodMetadata 对象
        MethodMetadata methodMetadata = this.methodMetadata.get(method);

        // <1> 情况一，如果任一不存在，使用默认的 defaultInvocationHandler
        if (genericService == null || methodMetadata == null) {
            return defaultInvocationHandler.invoke(proxy, method, args);
        }

        // 情况二，执行泛化调用
        String methodName = methodMetadata.getName(); // 方法名
        String[] parameterTypes = methodMetadata
                .getParams()
                .stream()
                .map(MethodParameterMetadata::getType)
                .toArray(String[]::new); // 参数类型
        return genericService.$invoke(methodName, parameterTypes, args);
    }

}

// DubboRegistration.java

/**
 * The {@link Registration} of Dubbo uses an external of {@link ServiceInstance} instance as the delegate.
 */
class DubboRegistration implements Registration {

    /**
     * Spring Cloud ServiceInstance
     */
    private final ServiceInstance delegate;

    public DubboRegistration(ServiceInstance delegate) {
        this.delegate = delegate;
    }

    @Override
    public String getServiceId() {
        return delegate.getServiceId();
    }

    @Override
    public String getHost() {
        return delegate.getHost();
    }

    @Override
    public int getPort() {
        return delegate.getPort();
    }

    @Override
    public boolean isSecure() {
        return delegate.isSecure();
    }

    @Override
    public URI getUri() {
        return delegate.getUri();
    }

    @Override
    public Map<String, String> getMetadata() {
        return delegate.getMetadata();
    }

    @Override
    public String getScheme() {
        return delegate.getScheme();
    }

}

// SpringCloudRegistryFactory.java

public class SpringCloudRegistryFactory implements RegistryFactory {

    private static ApplicationContext applicationContext;

    @Override
    public Registry getRegistry(URL url) {
        // <1> 获得 ServiceRegistry 对象
        ServiceRegistry<Registration> serviceRegistry = applicationContext.getBean(ServiceRegistry.class);
        // <2> 获得 DiscoveryClient 对象
        DiscoveryClient discoveryClient = applicationContext.getBean(DiscoveryClient.class);
        // <3> 创建 SpringCloudRegistry 对象
        return new SpringCloudRegistry(url, serviceRegistry, discoveryClient);
    }

    public static void setApplicationContext(ApplicationContext applicationContext) {
        SpringCloudRegistryFactory.applicationContext = applicationContext;
    }

}

// SpringCloudRegistry.java

/**
 * ServiceRegistry 对象
 */
private final ServiceRegistry<Registration> serviceRegistry;

/**
 * DiscoveryClient 对象
 */
private final DiscoveryClient discoveryClient;

public SpringCloudRegistry(URL url, ServiceRegistry<Registration> serviceRegistry,
                           DiscoveryClient discoveryClient) {
    super(url);
    this.serviceRegistry = serviceRegistry;
    this.discoveryClient = discoveryClient;
}

// SpringCloudRegistry.java

@Override
protected void doRegister(URL url) {
    // <1> 获得 serviceName
    final String serviceName = getServiceName(url);
    // <2> 创建 Registration 对象
    final Registration registration = createRegistration(serviceName, url);
    // <3> 注册到 serviceRegistry 中
    serviceRegistry.register(registration);
}

// SpringCloudRegistry.java

@Override
protected void doUnregister(URL url) {
    // 获得 serviceName
    final String serviceName = getServiceName(url);
    // 创建 Registration 对象
    final Registration registration = createRegistration(serviceName, url);
    // 取消注册从 serviceRegistry 中
    this.serviceRegistry.deregister(registration);
}

// SpringCloudRegistry.java

@Override
protected void doSubscribe(URL url, NotifyListener listener) {
    // <1> 获得 serviceName 数组
    List<String> serviceNames = getServiceNames(url, listener);
    // <2> 执行订阅
    doSubscribe(url, listener, serviceNames);
}

// SpringCloudRegistry.java

private void notifySubscriber(URL url, NotifyListener listener, List<ServiceInstance> serviceInstances) {
    // <1> 过滤掉非健康的 Dubbo 服务
    List<ServiceInstance> healthyInstances = new LinkedList<ServiceInstance>(serviceInstances);
    // <1> Healthy Instances
    filterHealthyInstances(healthyInstances);
    // <2> 创建 URL 数组
    List<URL> urls = buildURLs(url, healthyInstances);
    // <3> 通知订阅者
    this.notify(url, listener, urls);
}

// SpringCloudRegistry.java

@Override
protected void doUnsubscribe(URL url, NotifyListener listener) {
    // 忽略管理端
    if (isAdminProtocol(url)) {
        shutdownServiceNamesLookup();
    }
}