SpringBoot中自动将包内接口生成Dubbo的ReferenceBean

最新推荐文章于 2024-01-18 00:09:35 发布
最新推荐文章于 2024-01-18 00:09:35 发布
阅读量1k 收藏
点赞数 1
分类专栏： dubbo Spring Boot 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37607945/article/details/107001268
版权

首先引入依赖

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.7</version>
</dependency>

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-autoconfigure</artifactId>
    <version>2.7.7</version>
</dependency>

定义一个注解

@DubboReferenceScanIgnore
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboReferenceBeanRegistrar.class)
public @interface EnableDubboReferenceScan {

    /**
     * @return dubbo直连服务器地址
     */
    String url() default "";

    /**
     * @return 扫描的包路径
     */
    String[] basePackages();
}

通过这个注解传入指定的包名称

在@Import定义了一个实现了ImportBeanDefinitionRegistrar接口的对象，用于扫描指定包路径下的接口，然后根据接口类型生成ReferenceBean并注册到Spring容器当中，然后在使用的地方就像如下的方式可以使用了。

// 开启dubbo的扫描功能
@EnableDubboReferenceScan(basePackages = {"com.xquant.platform.test.trade"})
@SpringBootApplication
public class TradeTestClientStartMain {

    private final Logger logger = LoggerFactory.getLogger(getClass());

	// 像Spring注入一样注入一个Dubbo的Reference引用
    @Autowired
    private FacadeTradeTestService facadeTradeTestService;


    public static void main(String[] args) {
        SpringApplication.run(TradeTestClientStartMain.class);
    }
    
    @Bean
    public ApplicationRunner runner() {
        return args -> {
            facadeTradeTestService.newNormalTrade(TradeParamFactory4Bond.bondIn4CNBD(), null, "2016-05-06", null);
        };
    }
}

由于在ImportBeanDefinitionRegistrar需要使用到ApplicationContext这个Bean对象，但是此时通过ApplicationContextAware是无法引入的（ImportBeanDefinitionRegistrar此时是不会进行Bean实例化的），所以定义下面类

package com.xquant.platform.test.trade.client.env;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

/**
 * Created in 2020/6/21 20:35 by guanglai.zhou
 */
public class ClientSpringApplicationRunListener implements SpringApplicationRunListener {

    private static ApplicationContext applicationContext;
    private static ConfigurableEnvironment configurableEnvironment;
    private SpringApplication application;

    public ClientSpringApplicationRunListener(SpringApplication application, String[] args) {
        this.application = application;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static ConfigurableEnvironment getConfigurableEnvironment() {
        return configurableEnvironment;
    }

    @Override
    public void starting() {

    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        configurableEnvironment = environment;
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        applicationContext = context;
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {

    }

    @Override
    public void started(ConfigurableApplicationContext context) {

    }

    @Override
    public void running(ConfigurableApplicationContext context) {

    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {

    }
}

并在spring.factories文件中添加配置

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
com.xquant.platform.test.trade.client.env.ClientSpringApplicationRunListener

这样在Spring容器刷新之前就会将容器对象存到ClientSpringApplicationRunListener类中了
对应的DubboReferenceBeanRegistrar实现如下：

package com.xquant.platform.test.trade.client.anno;

import com.xquant.platform.test.trade.client.env.ClientSpringApplicationRunListener;
import com.xquant.platform.test.trade.client.filter.ReferenceBeanFilter;
import com.xquant.platform.test.trade.client.filter.impl.ReferenceBeanFilterImpl;
import org.apache.dubbo.config.annotation.Reference;
import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.config.spring.ReferenceBean;
import org.apache.dubbo.config.spring.ServiceBean;
import org.apache.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor;
import org.apache.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor;
import org.apache.dubbo.config.spring.beans.factory.annotation.ServiceBeanNameBuilder;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.StandardAnnotationMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import static com.alibaba.spring.util.AnnotationUtils.getAttribute;
import static java.lang.reflect.Proxy.newProxyInstance;
import static org.springframework.util.StringUtils.hasText;

/**
 * @author ：guanglai.zhou
 * @date ：Created in 2020/6/8 9:32
 * @description：注册Dubbo ReferenceBean
 */
public class DubboReferenceBeanRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware, ApplicationContextAware, BeanFactoryAware, BeanClassLoaderAware {

    /**
     * The bean name of {@link ReferenceAnnotationBeanPostProcessor}
     */
    public static final String BEAN_NAME = "referenceAnnotationBeanPostProcessor";

    /**
     * Cache size
     */
    private static final int CACHE_SIZE = Integer.getInteger(BEAN_NAME + ".cache.size", 32);
    private static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
    private static ReferenceBeanFilter referenceBeanFilter = new ReferenceBeanFilterImpl();
    private final ConcurrentMap<String, ReferenceBean<?>> referenceBeanCache =
            new ConcurrentHashMap<>(CACHE_SIZE);
    private final ConcurrentMap<String, ReferencedBeanInvocationHandler> referencedBeanInvocationHandlersCache =
            new ConcurrentHashMap<>();
    private String resourcePattern = DEFAULT_RESOURCE_PATTERN;
    private Environment environment;
    private ApplicationContext applicationContext = ClientSpringApplicationRunListener.getApplicationContext();
    private DefaultResourceLoader resourceLoader = new DefaultResourceLoader(ClassUtils.getDefaultClassLoader());
    private ResourcePatternResolver resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
    private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
    private BeanFactory beanFactory;
    private ClassLoader classLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        EnableDubboReferenceScan enableDubboReferenceScan = ((StandardAnnotationMetadata) importingClassMetadata).getIntrospectedClass().getAnnotation(EnableDubboReferenceScan.class);
        if (enableDubboReferenceScan != null) {
            String[] basePackages = enableDubboReferenceScan.basePackages();
            String url = enableDubboReferenceScan.url();
            Set<Class<?>> candidates = scan(basePackages);
            AnnotationAttributes attributes = new AnnotationAttributes();
            for (Class<?> injectedType : candidates) {
                /**
                 * The name of bean that annotated Dubbo's {@link Service @Service} in local Spring {@link ApplicationContext}
                 */
                String referencedBeanName = buildReferencedBeanName(attributes, injectedType);

                /**
                 * The name of bean that is declared by {@link Reference @Reference} annotation injection
                 */
                String referenceBeanName = getReferenceBeanName(attributes, injectedType);

                ReferenceBean referenceBean = null;
                try {
                    referenceBean = buildReferenceBeanIfAbsent(referenceBeanName, attributes, injectedType);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }

                boolean localServiceBean = isLocalServiceBean(referencedBeanName, referenceBean, attributes);

                registerReferenceBean(referencedBeanName, referenceBean, attributes, localServiceBean, injectedType);

                getOrCreateProxy(referencedBeanName, referenceBean, localServiceBean, injectedType);

            }
        }
    }

    /**
     * @param attributes           the attributes of {@link Reference @Reference}
     * @param serviceInterfaceType the type of Dubbo's service interface
     * @return The name of bean that annotated Dubbo's {@link Service @Service} in local Spring {@link ApplicationContext}
     */
    private String buildReferencedBeanName(AnnotationAttributes attributes, Class<?> serviceInterfaceType) {
        ServiceBeanNameBuilder serviceBeanNameBuilder = ServiceBeanNameBuilder.create(attributes, serviceInterfaceType, this.getEnvironment());
        return serviceBeanNameBuilder.build();
    }

    public Environment getEnvironment() {
        return environment;
    }

    @Override
    public void setEnvironment(Environment environment) {

        Assert.isInstanceOf(ConfigurableEnvironment.class, environment);

        this.environment = (ConfigurableEnvironment) environment;

    }

    /**
     * Get the bean name of {@link ReferenceBean} if {@link Reference#id() id attribute} is present,
     * or {@link #generateReferenceBeanName(AnnotationAttributes, Class) generate}.
     *
     * @param attributes     the {@link AnnotationAttributes attributes} of {@link Reference @Reference}
     * @param interfaceClass the {@link Class class} of Service interface
     * @return non-null
     * @since 2.7.3
     */
    private String getReferenceBeanName(AnnotationAttributes attributes, Class<?> interfaceClass) {
        // id attribute appears since 2.7.3
        String beanName = getAttribute(attributes, "id");
        if (!hasText(beanName)) {
            beanName = generateReferenceBeanName(attributes, interfaceClass);
        }
        return beanName;
    }

    /**
     * Build the bean name of {@link ReferenceBean}
     *
     * @param attributes     the {@link AnnotationAttributes attributes} of {@link Reference @Reference}
     * @param interfaceClass the {@link Class class} of Service interface
     * @return
     * @since 2.7.3
     */
    private String generateReferenceBeanName(AnnotationAttributes attributes, Class<?> interfaceClass) {
        StringBuilder beanNameBuilder = new StringBuilder("@Reference");

        if (!attributes.isEmpty()) {
            beanNameBuilder.append('(');
            for (Map.Entry<String, Object> entry : attributes.entrySet()) {
                beanNameBuilder.append(entry.getKey())
                        .append('=')
                        .append(entry.getValue())
                        .append(',');
            }
            // replace the latest "," to be ")"
            beanNameBuilder.setCharAt(beanNameBuilder.lastIndexOf(","), ')');
        }

        beanNameBuilder.append(" ").append(interfaceClass.getName());

        return beanNameBuilder.toString();
    }

    private ReferenceBean buildReferenceBeanIfAbsent(String referenceBeanName, AnnotationAttributes attributes,
                                                     Class<?> referencedType)
            throws Exception {

        ReferenceBean<?> referenceBean = referenceBeanCache.get(referenceBeanName);

        if (referenceBean == null) {
            ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
                    .create(attributes, applicationContext)
                    .interfaceClass(referencedType);
            referenceBean = beanBuilder.build();
            referenceBeanCache.put(referenceBeanName, referenceBean);
        } else if (!referencedType.isAssignableFrom(referenceBean.getInterfaceClass())) {
            throw new IllegalArgumentException("reference bean name " + referenceBeanName + " has been duplicated, but interfaceClass " +
                    referenceBean.getInterfaceClass().getName() + " cannot be assigned to " + referencedType.getName());
        }
        return referenceBean;
    }

    /**
     * Is Local Service bean or not?
     *
     * @param referencedBeanName the bean name to the referenced bean
     * @return If the target referenced bean is existed, return <code>true</code>, or <code>false</code>
     * @since 2.7.6
     */
    private boolean isLocalServiceBean(String referencedBeanName, ReferenceBean referenceBean, AnnotationAttributes attributes) {
        return existsServiceBean(referencedBeanName) && !isRemoteReferenceBean(referenceBean, attributes);
    }

    /**
     * Check the {@link ServiceBean} is exited or not
     *
     * @param referencedBeanName the bean name to the referenced bean
     * @return if exists, return <code>true</code>, or <code>false</code>
     * @revised 2.7.6
     */
    private boolean existsServiceBean(String referencedBeanName) {
        return applicationContext.containsBean(referencedBeanName) &&
                applicationContext.isTypeMatch(referencedBeanName, ServiceBean.class);

    }

    private boolean isRemoteReferenceBean(ReferenceBean referenceBean, AnnotationAttributes attributes) {
        boolean remote = Boolean.FALSE.equals(referenceBean.isInjvm()) || Boolean.FALSE.equals(attributes.get("injvm"));
        return remote;
    }

    /**
     * Register an instance of {@link ReferenceBean} as a Spring Bean
     *
     * @param referencedBeanName The name of bean that annotated Dubbo's {@link Service @Service} in the Spring {@link ApplicationContext}
     * @param referenceBean      the instance of {@link ReferenceBean} is about to register into the Spring {@link ApplicationContext}
     * @param attributes         the {@link AnnotationAttributes attributes} of {@link Reference @Reference}
     * @param localServiceBean   Is Local Service bean or not
     * @param interfaceClass     the {@link Class class} of Service interface
     * @since 2.7.3
     */
    private void registerReferenceBean(String referencedBeanName, ReferenceBean referenceBean,
                                       AnnotationAttributes attributes,
                                       boolean localServiceBean, Class<?> interfaceClass) {

        ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory) getBeanFactory();

        String beanName = getReferenceBeanName(attributes, interfaceClass);

        if (localServiceBean) {  // If @Service bean is local one
            /**
             * Get  the @Service's BeanDefinition from {@link BeanFactory}
             * Refer to {@link ServiceAnnotationBeanPostProcessor#buildServiceBeanDefinition}
             */
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanFactory.getBeanDefinition(referencedBeanName);
            RuntimeBeanReference runtimeBeanReference = (RuntimeBeanReference) beanDefinition.getPropertyValues().get("ref");
            // The name of bean annotated @Service
            String serviceBeanName = runtimeBeanReference.getBeanName();
            // register Alias rather than a new bean name, in order to reduce duplicated beans
            beanFactory.registerAlias(serviceBeanName, beanName);
        } else { // Remote @Service Bean
            if (!beanFactory.containsBean(beanName)) {
                beanFactory.registerSingleton(beanName, referenceBean);
            }
        }
    }

    /**
     * Get or Create a proxy of {@link ReferenceBean} for the specified the type of Dubbo service interface
     *
     * @param referencedBeanName   The name of bean that annotated Dubbo's {@link Service @Service} in the Spring {@link ApplicationContext}
     * @param referenceBean        the instance of {@link ReferenceBean}
     * @param localServiceBean     Is Local Service bean or not
     * @param serviceInterfaceType the type of Dubbo service interface
     * @return non-null
     * @since 2.7.4
     */
    private Object getOrCreateProxy(String referencedBeanName, ReferenceBean referenceBean, boolean localServiceBean,
                                    Class<?> serviceInterfaceType) {
        if (localServiceBean) { // If the local @Service Bean exists, build a proxy of Service
            return newProxyInstance(getClassLoader(), new Class[]{serviceInterfaceType},
                    newReferencedBeanInvocationHandler(referencedBeanName));
        } else {
            exportServiceBeanIfNecessary(referencedBeanName); // If the referenced ServiceBean exits, export it immediately
            return referenceBean.get();
        }
    }

    private void exportServiceBeanIfNecessary(String referencedBeanName) {
        if (existsServiceBean(referencedBeanName)) {
            ServiceBean serviceBean = getServiceBean(referencedBeanName);
            if (!serviceBean.isExported()) {
                serviceBean.export();
            }
        }
    }

    private ServiceBean getServiceBean(String referencedBeanName) {
        return applicationContext.getBean(referencedBeanName, ServiceBean.class);
    }

    private InvocationHandler newReferencedBeanInvocationHandler(String referencedBeanName) {
        return referencedBeanInvocationHandlersCache.computeIfAbsent(referencedBeanName,
                ReferencedBeanInvocationHandler::new);
    }

    public ApplicationContext getApplicationContext() {
        if (applicationContext == null) {
            applicationContext = ClientSpringApplicationRunListener.getApplicationContext();
        }
        return applicationContext;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    private Set<Class<?>> scan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<Class<?>> beanClasses = new LinkedHashSet<Class<?>>();
        for (String basePackage : basePackages) {
            beanClasses.addAll(doScan(basePackage));
        }
        return beanClasses;
    }

    private Set<Class<?>> doScan(String basePackage) {
        Set<Class<?>> candidates = new LinkedHashSet<Class<?>>();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                    + resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
            for (Resource resource : resources) {
                if (resource.isReadable()) {
                    try {
                        MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                        String className = metadataReader.getClassMetadata().getClassName();
                        Class<?> aClass = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
                        // 当目标类是接口并且自动生成Dubbo的ReferenceBean时不被忽略
                        if (referenceBeanFilter.isCandidate(aClass)) {
                            candidates.add(aClass);
                        }
                    } catch (Throwable ex) {
                        throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource,
                                ex);
                    }
                }
            }
        } catch (IOException ex) {
            throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
        }
        return candidates;
    }

    /**
     * Resolve the specified base package into a pattern specification for
     * the package search path.
     * <p>The default implementation resolves placeholders against system properties,
     * and converts a "."-based package path to a "/"-based resource path.
     *
     * @param basePackage the base package as specified by the user
     * @return the pattern specification to be used for package searching
     */
    protected String resolveBasePackage(String basePackage) {
        return ClassUtils.convertClassNameToResourcePath(this.environment.resolveRequiredPlaceholders(basePackage));
    }

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

    public ClassLoader getClassLoader() {
        return classLoader;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    private class ReferencedBeanInvocationHandler implements InvocationHandler {

        private final String referencedBeanName;

        private Object bean;

        private ReferencedBeanInvocationHandler(String referencedBeanName) {
            this.referencedBeanName = referencedBeanName;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = null;
            try {
                if (bean == null) {
                    init();
                }
                result = method.invoke(bean, args);
            } catch (InvocationTargetException e) {
                // re-throws the actual Exception.
                throw e.getTargetException();
            }
            return result;
        }

        private void init() {
            ServiceBean serviceBean = getApplicationContext().getBean(referencedBeanName, ServiceBean.class);
            this.bean = serviceBean.getRef();
        }
    }
}

其中可能会使用到一些Dubbo中的类，但是由于访问权限的问题，无法访问因此拷贝一份到自己的项目中即可，ReferenceBeanBuilder和AnnotationPropertyValuesAdapter。

冬日魔幻之旅-seata+dubbo+nacos+springboot解决分布式事务的全网段唯一实践之作(上)
lifetragedy的专栏
01-22 9076
开篇 阿里把FESCAR开源了，开源后的名称叫SEATA。目前GIT上已经超1万3的星了。 可是笔者遍历全网段，无一篇是生产实用级说明同时GIT官网上的相关文档缺失以及Sample都太HelloWorld了，无法应用在真正的生产环境上。 于是笔者结合了在6，7年前那时在那个MQ年代来解决分布式事务的经验，结合这次的SEATA（最新一次COMMIT在2019年12月底）来讲一下最最新的也是目前...
Spring Boot使用dubbo-spring-boot-starter集成Dubbo
a273127743的博客
10-07 3845
简介： Apache官方文档：https://github.com/apache/incubator-dubbo-spring-boot-project   Dubbo Spring Boot 工程致力于简化 Dubbo RPC 框架在 Spring Boot 应用场景的开发。同时也整合了 Spring Boot 特性： 自动装配 (比如： 注解驱动, 自动装配等). Productio...
Spring Boot @Bean 参考和总结
回纹勾边宝相花团
05-21 373
What is a Spring Bean? https://www.baeldung.com/spring-bean Chapter 4. Creating and using bean definitions https://docs.spring.io/spring-javaconfig/docs/1.0.0.m3/reference/html/creating-bean-definitio...
dubbo服务的对象 通过 Context 上下文获取 Bean
a1035434631的博客
02-07 2797
dubbo服务的对象 通过 Context 上下文获取 Bean 通常我们在使用spring的项目中注入duubo服务时,会使用 @DubboReference 注解或通过xml配置的方式注入, 但是如果在非 spring管理下的工程中,如某个工具类中使用 dubbo 的 bean 就不能使用这个注解了. 那么我可以从 context上下文中获取到注入的bean 步骤如下: 1.先从 springContext 中获取到 ReferenceAnnotationBeanPostProcessor 2
Dubbo之ReferenceBean
zhanghuyi2022的博客
07-09 1080
上次我们了解了Dubbo之ServiceBean ，dubbo把自定义的Service服务以ServiceBean的形式注册到SpringIOC容器中，由SpringIOC来管理dubbo服务的生命周期。 ServiceBean是服务提供方，今天我们来看下服务消费方是怎么加载的，核心入口类是ReferenceBean。我们在配置文件加上 或者在成员变量上加上注解@Reference， 生成的对象是ReferenceBean，当然不完全是，其实生成的是一个代理类。 举个例...
Spring整合Dubbo,@Reference注解源码解析
最新发布
qq_43253125的博客
01-18 2000
1.因为你在解析@Reference之前肯定会先解析@Service注解，然后肯定是先扔到自己的容器中然后再导出到注册中心，然后你在解析@Reference注解的时候就会判断到底你要引入的这个类是远程服务的还是本地服务的，如果是本地服务的（就是上面那个existsServiceBean(referencedBeanName)的判断，这样就不用走服务引入的逻辑，就会快很多）referenceBeanName:这个名字可以看到就是ReferenceBean的beanName，这个应该没啥异议，就是他的真名;
dubbo注入找不到bean_dubbo服务引用过程
weixin_36257799的博客
12-27 1938
点赞再看，养成习惯，微信搜一搜【三太子敖丙】关注这个喜欢写情怀的程序员。 本文 GitHub https://github.com/JavaFamily 已收录，有一线大厂面试完整考点、资料以及我的系列文章。上篇文章我们已经了解了 Dubbo 服务暴露全过程，这篇文章我就带着大家再来看看 Dubbo 服务引入全流程，这篇服务引入写完下一篇就要来个全链路打通了，看看大家看完会不会有种任督二脉都被打...
普通项目改造分布式，引入dubbo+zookeeper以及使用maven生成可执行的dubbo服务jar包
a281246240的专栏
08-23 752
一、背景 假如当前有一个系统，里面包含了用户模块、积分模块、商城模块...等等等，非分布式的做法是开一个web工程，把所有的模块放到同一个系统中，前端web页面也放其中，称为单体工程。很明显，这种做法会产生很多问题，臃肿、扩展延伸性差、性能瓶颈低、不利研发分组等。在分布式下则不同，每个模块都成为独立的一个系统，各个系统之间相互调用，加上前后端分离，让服务器端只提供接口，供pcweb、移动web、...
记一次 SpringBoot 项目启动失败排查 和 DubboReference 源码分析
yyyy11119的博客
12-17 342
问题现象在我们项目中有一个公司内部的二方包，里面有一个类： MvcInterceptorAutoConfiguration ，里面定一个了一个 Bean accessContextResolver 。生成这个 Bean 需要自动注入另一个 Bean ：accessContextService。代码如下：public class MvcInterceptorAutoConfiguration imp...
springboot 整合dubbo启动 java.lang.NoSuchMethodError 异常
CoreyXuu的博客
04-02 3513
异常描述:springboot整合dubbo项目启动报错 Exception in thread "main" java.lang.NoSuchMethodError: org.springframework.core.annotation.AnnotationAwareOrderComparator.sort(Ljava/util/List;)V at org.springfram...
SpringBoot——SpringBoot集成Dubbo
贝尔摩德苦艾酒
05-29 8592
SpringBoot——SpringBoot集成Dubbo
SpringBoot集成Dubbo案例
my_err的博客
08-12 348
Docker下安装Zookeeper: docker images查看安装到的镜像，2181端口是对客户端提供服务的端口 [root@localhost webapps]# docker pull zookeeper [root@localhost webapps]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE docker.io/zoo
Spring 源码学习 02：关于 Spring IoC 和 Bean 的概念
程序员小航
12-01 179
前言 在前一篇文章中介绍了如何构建源码阅读环境，既然构建好了源码环境，本地也可以正常运行，那就开始阅读源码吧！ 在阅读源码时，会参考官方文档，很多概念在官网都可以得到答案，有兴趣的小伙伴们可以继续阅读，当做复习，写的不足之处，希望多多指导。 IoC 和 DI IoC IoC（Inversion of Control），即控制反转。 之前是在对象内部 new 创建其他对象，然后使用。 而现在 Spring 中有一个容器可以在创建管理这些对象，并且将对象依赖的其他对象注入到这个对象中，这些对象的创建、销毁都由
手动调用指定Dubbo接口（一）----Spring注入篇
lkforce
09-13 6405
初衷 能不能输入任意的dubbo接口名字，输入参数，然后就可以调用这个接口呢？ 对于REST风格的接口，我们有Postman，Advanced REST client等一堆工具可以用，但对于dubbo接口却没有直接并且通用的调用方式。当然也可以写针对某个接口的测试调用方法，但是不同dubbo接口的调用方法不统一，新增一个接口就要新增对这个接口的测试调用方法，很麻烦。 思路 在dubb...
Spring boot配置Dubbo三种方式
热门推荐
天高任鸟飞
09-08 3万+
方式一 使用注解的方式 导入dubbo-starter 在application.properties配置属性 使用@Service暴露服务 使用@Reference引用服务 使用@EnableDubbo开启注解Dubbo功能 或者配置包扫描 dubbo.scan.base-packages=com.atguigu.gmall 开启注解、包扫描，配置一个即可 这种方式 可...
Dubbo ServiceBean 和 Referencebean 的接口设计与实现
一个天秤座的架构师
03-03 2万+
Spring Schema XML拓展机制：dubbo全透明融入spring的实现基础 在spring项目启动，会加载并解析resources目录下的xml，然后将xml配置文件中的配置加载成spring容器的bean，dubbo需要定义dubbo_provider.xml或consumer_provider.xml并加入到applicationContext.xml中。 <?xml version="1.0"encoding="UTF-8"?> <web-app id="WebA
dubbo的服务引用
景川的博客
02-18 571
分析完dubbo的服务发布再接着看看服务引用，和服务发布一样的，引用服务也是从配置文件开始： 一. 配置文件开始 <dubbo:reference id="demoService" interface="org.apache.dubbo.demo.service.DemoService" version="2.0.0" group="default"/> 一般引用服务我们可以在xml中配置这样的代码，然后就能在代码中引用到这个服务接口了 那么实际上他也
Dubbo——SpringBoot集成Dubbo（@Autowired和@Reference的区别、Dubbo的服务治理）
Strine的博客
05-16 1999
在上一篇文章中我们讲了如何使用原生API发起远程调用，显然这种方式肯定是非常麻烦的，因此我们这里就讲如何使用SpringBoot去集成Dubbo将这些配置简化。
Dubbo详解+SpringBoot配置Dubbo
weixin_34337265的博客
09-06 840
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot 1.x整合Dubbo解决@Reference注解问题
本篇文章将详细介绍如何在SpringBoot中正确地整合Dubbo，并解决`@Reference`注解的相关问题。 首先，我们需要了解的是SpringBoot 2.x与Dubbo的兼容性问题。SpringBoot 2.x引入了新的特性，与Dubbo的某些配置可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lang20150928

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值