Dubbo之——改造Dubbo,使其能够兼容Spring 4注解配置-阿里云开发者社区

开发者社区> 阿里云MVP> 正文
登录阅读全文

Dubbo之——改造Dubbo,使其能够兼容Spring 4注解配置

简介: Dubbo之——改造Dubbo,使其能够兼容Spring 4注解配置

Dubbo之——改造Dubbo,使其能够兼容Spring 4注解配置

转载请注明出处:http://blog.csdn.net/l1028386804/article/details/70040928

而随着Spring Boot的大热,Java-Base方式配置Spring也变得越来越流行。
Dubbo + Boot的开发模式,也是较为常见的组合方式。
但是,当使用Dubbo在高版本Spring环境中使用注解方式配置时,会因为一些代码版本的原因导致整合出现问题。

  1. Dubbo原生的注解配置
    Dubbo本身就是基于Spring的,而且原生就提供注解配置:

服务提供方配置:

服务提供方注解:
[java] view plain copy
import com.alibaba.dubbo.config.annotation.Service;

@Service(version=”1.0.0”)
public class FooServiceImpl implements FooService {
// ……
}
服务消费方注解:
[java] view plain copy
import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Component;

@Component
public class BarAction {

@Reference(version="1.0.0")  
private FooService fooService;

}
服务消费方配置:
[html] view plain copy

通过官方的例子,就可以看出Dubbo使用xml配置 来开启注解配置,并提供 com.alibaba.dubbo.config.annotation.Service注解进行服务注册,提供com.alibaba.dubbo.config.annotation.Reference注解进行服务注入。
2.实现机制
可以看出,内部机制都是依托于标签。 通过源码分析,Dubbo对于Spring xml解析处理由com.alibaba.dubbo.config.spring.schema.DubboNamespaceHandler提供:
DubboNamespaceHandler.java
[java] view plain copy
package com.alibaba.dubbo.config.spring.schema;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

import com.alibaba.dubbo.common.Version;
import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ConsumerConfig;
import com.alibaba.dubbo.config.ModuleConfig;
import com.alibaba.dubbo.config.MonitorConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.spring.AnnotationBean;
import com.alibaba.dubbo.config.spring.ReferenceBean;
import com.alibaba.dubbo.config.spring.ServiceBean;

/**

  • DubboNamespaceHandler
  • @author william.liangf
  • @export
    */

public class DubboNamespaceHandler extends NamespaceHandlerSupport {

static {  
    Version.checkDuplicate(DubboNamespaceHandler.class);  
}  

public void init() {  
    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));  
    registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));  
    registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));  
    registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));  
    registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));  
    registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));  
    registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));  
    registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));  
    registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));  
    registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));  
}

}
通过上面的代码可以很直观的发现,标签实际是由com.alibaba.dubbo.config.spring.schema.DubboBeanDefinitionParser解析:
DubboBeanDefinitionParser.java
[java] view plain copy
/**

  • AbstractBeanDefinitionParser
  • @author william.liangf
  • @export
    */

public class DubboBeanDefinitionParser implements BeanDefinitionParser {

private static final Logger logger = LoggerFactory.getLogger(DubboBeanDefinitionParser.class);  

private final Class<?> beanClass;  

private final boolean required;  

public DubboBeanDefinitionParser(Class<?> beanClass, boolean required) {  
    this.beanClass = beanClass;  
    this.required = required;  
}  

public BeanDefinition parse(Element element, ParserContext parserContext) {  
    return parse(element, parserContext, beanClass, required);  
}  

@SuppressWarnings("unchecked")  
private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) {  
    //略  
}

可以看到这个类实现了Spring的org.springframework.beans.factory.xml.BeanDefinitionParser接口,从而完成Spring Bean的解析工作。
而registerBeanDefinitionParser(“annotation”, new DubboBeanDefinitionParser(AnnotationBean.class, true));就是将标签,解析成com.alibaba.dubbo.config.spring.AnnotationBean并注册到Spring中。
3.AnnotationBean分析
先来看看源码:
AnnotationBean.java
[java] view plain copy
package com.alibaba.dubbo.config.spring;

/**

  • AnnotationBean
  • @author william.liangf
  • @export
    */

public class AnnotationBean extends AbstractConfig implements DisposableBean, BeanFactoryPostProcessor, BeanPostProcessor, ApplicationContextAware {

private static final long serialVersionUID = -7582802454287589552L;  

private static final Logger logger = LoggerFactory.getLogger(Logger.class);  

private String annotationPackage;  

private String[] annotationPackages;  

private final Set<ServiceConfig<?>> serviceConfigs = new ConcurrentHashSet<ServiceConfig<?>>();  

private final ConcurrentMap<String, ReferenceBean<?>> referenceConfigs = new ConcurrentHashMap<String, ReferenceBean<?>>();  

public String getPackage() {  
    return annotationPackage;  
}  

public void setPackage(String annotationPackage) {  
    this.annotationPackage = annotationPackage;  
    this.annotationPackages = (annotationPackage == null || annotationPackage.length() == 0) ? null  
            : Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);  
}  

private ApplicationContext applicationContext;  

public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  
    this.applicationContext = applicationContext;  
}  

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)  
        throws BeansException {  
    if (annotationPackage == null || annotationPackage.length() == 0) {  
        return;  
    }  
    if (beanFactory instanceof BeanDefinitionRegistry) {  
        try {  
            // init scanner  
            Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");  
            Object scanner = scannerClass.getConstructor(new Class<?>[] {BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[] {(BeanDefinitionRegistry) beanFactory, true});  
            // add filter  
            Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");  
            Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);  
            Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));  
            addIncludeFilter.invoke(scanner, filter);  
            // scan packages  
            String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);  
            Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});  
            scan.invoke(scanner, new Object[] {packages});  
        } catch (Throwable e) {  
            // spring 2.0  
        }  
    }  
}  

public void destroy() throws Exception {  
    for (ServiceConfig<?> serviceConfig : serviceConfigs) {  
        try {  
            serviceConfig.unexport();  
        } catch (Throwable e) {  
            logger.error(e.getMessage(), e);  
        }  
    }  
    for (ReferenceConfig<?> referenceConfig : referenceConfigs.values()) {  
        try {  
            referenceConfig.destroy();  
        } catch (Throwable e) {  
            logger.error(e.getMessage(), e);  
        }  
    }  
}  

public Object postProcessAfterInitialization(Object bean, String beanName)  
        throws BeansException {  
    if (! isMatchPackage(bean)) {  
        return bean;  
    }  
    Service service = bean.getClass().getAnnotation(Service.class);  
    if (service != null) {  
        ServiceBean<Object> serviceConfig = new ServiceBean<Object>(service);  
        if (void.class.equals(service.interfaceClass())  
                && "".equals(service.interfaceName())) {  
            if (bean.getClass().getInterfaces().length > 0) {  
                serviceConfig.setInterface(bean.getClass().getInterfaces()[0]);  
            } else {  
                throw new IllegalStateException("Failed to export remote service class " + bean.getClass().getName() + ", cause: The @Service undefined interfaceClass or interfaceName, and the service class unimplemented any interfaces.");  
            }  
        }  
        if (applicationContext != null) {  
            serviceConfig.setApplicationContext(applicationContext);  
            if (service.registry() != null && service.registry().length > 0) {  
                List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();  
                for (String registryId : service.registry()) {  
                    if (registryId != null && registryId.length() > 0) {  
                        registryConfigs.add((RegistryConfig)applicationContext.getBean(registryId, RegistryConfig.class));  
                    }  
                }  
                serviceConfig.setRegistries(registryConfigs);  
            }  
            if (service.provider() != null && service.provider().length() > 0) {  
                serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(),ProviderConfig.class));  
            }  
            if (service.monitor() != null && service.monitor().length() > 0) {  
                serviceConfig.setMonitor((MonitorConfig)applicationContext.getBean(service.monitor(), MonitorConfig.class));  
            }  
            if (service.application() != null && service.application().length() > 0) {  
                serviceConfig.setApplication((ApplicationConfig)applicationContext.getBean(service.application(), ApplicationConfig.class));  
            }  
            if (service.module() != null && service.module().length() > 0) {  
                serviceConfig.setModule((ModuleConfig)applicationContext.getBean(service.module(), ModuleConfig.class));  
            }  
            if (service.provider() != null && service.provider().length() > 0) {  
                serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(), ProviderConfig.class));  
            } else {  

            }  
            if (service.protocol() != null && service.protocol().length > 0) {  
                List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();  
                for (String protocolId : service.registry()) {  
                    if (protocolId != null && protocolId.length() > 0) {  
                        protocolConfigs.add((ProtocolConfig)applicationContext.getBean(protocolId, ProtocolConfig.class));  
                    }  
                }  
                serviceConfig.setProtocols(protocolConfigs);  
            }  
            try {  
                serviceConfig.afterPropertiesSet();  
            } catch (RuntimeException e) {  
                throw (RuntimeException) e;  
            } catch (Exception e) {  
                throw new IllegalStateException(e.getMessage(), e);  
            }  
        }  
        serviceConfig.setRef(bean);  
        serviceConfigs.add(serviceConfig);  
        serviceConfig.export();  
    }  
    return bean;  
}  

public Object postProcessBeforeInitialization(Object bean, String beanName)  
        throws BeansException {  
    if (! isMatchPackage(bean)) {  
        return bean;  
    }  
    Method[] methods = bean.getClass().getMethods();  
    for (Method method : methods) {  
        String name = method.getName();  
        if (name.length() > 3 && name.startsWith("set")  
                && method.getParameterTypes().length == 1  
                && Modifier.isPublic(method.getModifiers())  
                && ! Modifier.isStatic(method.getModifiers())) {  
            try {  
                Reference reference = method.getAnnotation(Reference.class);  
                if (reference != null) {  
                    Object value = refer(reference, method.getParameterTypes()[0]);  
                    if (value != null) {  
                        method.invoke(bean, new Object[] {  });  
                    }  
                }  
            } catch (Throwable e) {  
                logger.error("Failed to init remote service reference at method " + name + " in class " + bean.getClass().getName() + ", cause: " + e.getMessage(), e);  
            }  
        }  
    }  
    Field[] fields = bean.getClass().getDeclaredFields();  
    for (Field field : fields) {  
        try {  
            if (! field.isAccessible()) {  
                field.setAccessible(true);  
            }  
            Reference reference = field.getAnnotation(Reference.class);  
            if (reference != null) {  
                Object value = refer(reference, field.getType());  
                if (value != null) {  
                    field.set(bean, value);  
                }  
            }  
        } catch (Throwable e) {  
            logger.error("Failed to init remote service reference at filed " + field.getName() + " in class " + bean.getClass().getName() + ", cause: " + e.getMessage(), e);  
        }  
    }  
    return bean;  
}  

private Object refer(Reference reference, Class<?> referenceClass) { //method.getParameterTypes()[0]  
    String interfaceName;  
    if (! "".equals(reference.interfaceName())) {  
        interfaceName = reference.interfaceName();  
    } else if (! void.class.equals(reference.interfaceClass())) {  
        interfaceName = reference.interfaceClass().getName();  
    } else if (referenceClass.isInterface()) {  
        interfaceName = referenceClass.getName();  
    } else {  
        throw new IllegalStateException("The @Reference undefined interfaceClass or interfaceName, and the property type " + referenceClass.getName() + " is not a interface.");  
    }  
    String key = reference.group() + "/" + interfaceName + ":" + reference.version();  
    ReferenceBean<?> referenceConfig = referenceConfigs.get(key);  
    if (referenceConfig == null) {  
        referenceConfig = new ReferenceBean<Object>(reference);  
        if (void.class.equals(reference.interfaceClass())  
                && "".equals(reference.interfaceName())  
                && referenceClass.isInterface()) {  
            referenceConfig.setInterface(referenceClass);  
        }  
        if (applicationContext != null) {  
            referenceConfig.setApplicationContext(applicationContext);  
            if (reference.registry() != null && reference.registry().length > 0) {  
                List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();  
                for (String registryId : reference.registry()) {  
                    if (registryId != null && registryId.length() > 0) {  
                        registryConfigs.add((RegistryConfig)applicationContext.getBean(registryId, RegistryConfig.class));  
                    }  
                }  
                referenceConfig.setRegistries(registryConfigs);  
            }  
            if (reference.consumer() != null && reference.consumer().length() > 0) {  
                referenceConfig.setConsumer((ConsumerConfig)applicationContext.getBean(reference.consumer(), ConsumerConfig.class));  
            }  
            if (reference.monitor() != null && reference.monitor().length() > 0) {  
                referenceConfig.setMonitor((MonitorConfig)applicationContext.getBean(reference.monitor(), MonitorConfig.class));  
            }  
            if (reference.application() != null && reference.application().length() > 0) {  
                referenceConfig.setApplication((ApplicationConfig)applicationContext.getBean(reference.application(), ApplicationConfig.class));  
            }  
            if (reference.module() != null && reference.module().length() > 0) {  
                referenceConfig.setModule((ModuleConfig)applicationContext.getBean(reference.module(), ModuleConfig.class));  
            }  
            if (reference.consumer() != null && reference.consumer().length() > 0) {  
                referenceConfig.setConsumer((ConsumerConfig)applicationContext.getBean(reference.consumer(), ConsumerConfig.class));  
            }  
            try {  
                referenceConfig.afterPropertiesSet();  
            } catch (RuntimeException e) {  
                throw (RuntimeException) e;  
            } catch (Exception e) {  
                throw new IllegalStateException(e.getMessage(), e);  
            }  
        }  
        referenceConfigs.putIfAbsent(key, referenceConfig);  
        referenceConfig = referenceConfigs.get(key);  
    }  
    return referenceConfig.get();  
}  

private boolean isMatchPackage(Object bean) {  
    if (annotationPackages == null || annotationPackages.length == 0) {  
        return true;  
    }  
    String beanClassName = bean.getClass().getName();  
    for (String pkg : annotationPackages) {  
        if (beanClassName.startsWith(pkg)) {  
            return true;  
        }  
    }  
    return false;  
}

}
这个AnnotationBean实现了几个Spring生命周期接口,从而完成Dubbo整合Spring 的操作。
org.springframework.beans.factory.config.BeanFactoryPostProcessor
先来看看Spring文档中的介绍:
[plain] view plain copy
BeanFactoryPostProcessor operates on the bean configuration metadata; that is, the Spring IoC container allows a BeanFactoryPostProcessor to read the configuration metadata and potentially change it before the container instantiates any beans other than BeanFactoryPostProcessors.
BeanFactoryPostProcessor可以用于在Spring IoC容器实例化Bean之前,对Spring Bean配置信息进行一些操作
通过Spring文档,可以清楚这个接口的功能,那再来看看Dubbo的AnnotationBean是如何实现这个接口的:
[java] view plain copy
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (annotationPackage == null || annotationPackage.length() == 0) {
return;
}
if (beanFactory instanceof BeanDefinitionRegistry) {
try {
// init scanner
Class

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
+ 订阅

阿里云最有价值专家,是专注于帮助他人充分了解和使用阿里云技术的意见领袖。

官方博客
官网链接
精彩专题