必逍遥
必逍遥

【Dubbo】2.服务发布和引用

服务发布

SpringContainer启动之后就开始进入Spring的生命周期管理了，依赖Spring提供的各种扩展机制，比如spring会自动查找dubbo.jar!/META-INF/spring.handlers文件的内容，实现命名空间自定义扩展

DubboNamespaceHandler

Dubbo的配置文件中有很多xml节点比如：

如果我们要自己写标签同时整合到Spring，首先要查看官方文档找到Xml扩展接口，Dubbo就是通过DubboNamespaceHandler继承Spring提供的扩展接口NamespaceHandlerSupport，允许Dubbo自定义Xml标签向Spring容器注册BeanDefinition，而Xml文件经过DubboBeanDefinitionParser.parse()之后又具备了XML向Java代码转换的能力，具体的配置参数如下所示，后面有专题章节对配置以及转换过程做详细介绍，这里只需要了解下面的xml等同于手写Dubbo Api代码即可。

Consumer配置

Provider配置

DubboNamespaceHandler只有一个init()方法，从中观察到，和标签注册的分别是ServiceBean和ReferenceBean对象，而其他的元素注册的都是Config对象，表明和被作者赋予高于普通配置的行为和地位（皆继承AbstractConfig）

ServiceBean和ReferenceBean是Dubbo与Spring容器整合的核心方法

每一个elementName都是xml中的标签，有其相应属性，具有可配置的能力

package org.apache.dubbo.config.spring.schema;
class DubboNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        // 代码太长放不下，为了格式漂亮定义下变量
        // register=registerBeanDefinitionParser
        // BeanDefParser=DubboBeanDefinitionParser
        register("application", new BeanDefParser(ApplicationConfig.class, true));
        register("module", new BeanDefParser(ModuleConfig.class, true));
        register("registry", new BeanDefParser(RegistryConfig.class, true));
        register("config-center", new BeanDefParser(ConfigCenterBean.class, true));
        register("metadata-report", new BeanDefParser(MetadataReportConfig.class, true));
        register("monitor", new BeanDefParser(MonitorConfig.class, true));
        register("metrics", new BeanDefParser(MetricsConfig.class, true));
        register("provider", new BeanDefParser(ProviderConfig.class, true));
        register("consumer", new BeanDefParser(ConsumerConfig.class, true));
        register("protocol", new BeanDefParser(ProtocolConfig.class, true));
        // 名字是以Bean结尾的区别于上面的Config
        register("service", new BeanDefParser(ServiceBean.class, true));
        register("reference", new BeanDefParser(ReferenceBean.class, false));
        register("annotation", new BeanDefParser());
    }
}

ServiceBean

Dubbo要求标签由Provider端定义，下面开始介绍Provider的定义入口ServiceBean。其泛型由interface="org.apache.dubbo.demo.DemoService"字段指定。

package org.apache.dubbo.config.spring;
public class ServiceBean extends ServiceConfig
implements InitializingBean, DisposableBean, BeanNameAware,
      ApplicationContextAware, ApplicationListener,
      ApplicationEventPublisherAware

ServiceBean实现了好多接口，看下各自的作用

接口 方法 作用
InitializingBean afterPropertiesSet() bean启动扩展
DisposableBean destroy() bean销毁扩展
ApplicationContextAware setApplicationContext(ApplicationContext) 注入spring环境
ApplicationEventPublisherAware setApplicationEventPublisher(Publisher) 注入事件发布
BeanNameAware setBeanName(String name) 注入当前bean的名字
ServiceConfig export()，doExportUrls() 生成Protocol

  1. ServiceBean实现了Spring的InitializingBean扩展，容器启动时会自动执行afterPropertiesSet()

  2. ServiceBean实现了Spring的DisposableBean扩展，Bean销毁时会自动执行destroy()

  3. ServiceBean实现了Spring的ApplicationContextAware扩展，应用启动完毕会自动注入ApplicationContext上下文，方便Dubbo从全局获取Bean对象

  4. ServiceBean实现了Spring的ApplicationEventPublisherAware扩展，具有发布事件的能力

  5. ServiceBean实现了Spring的BeanNameAware扩展，知道自己的BeanName

  6. ServiceBean继承了ServiceConfig，主要目的是根据Config生成dubbo协议

    dubbo://host/com.foo.FooService?route=route&cluster=&version=1.0.0

Spring容器启动自动调用afterPropertiesSet()，时序上先于onApplicationEvent()

ServiceBean.afterPropertiesSet():

afterPropertiesSet()：代码很长分两部分说明

1.标签优先级设定：根据BeanDefinition标签设定优先级

2.判断当前Spring版本是否支持ApplicationListener()，否则延迟导出直到Spring容器启动完毕

// 标签优先级设定伪代码
if exist() {find(); setProviders(ProviderBean)}
if exist() { setApplication(ApplicationBean)}
if exist() {super.setRegistries(ModuleBean)}
if exist() {super.setProtocol(ProtocolBean)}
...
// 以上设置完毕判断spring是否支持事件监听，低版本兼容
if !supportedApplicationListener {export();}

Spring容器启动完毕后监听ContextRefreshedEvent执行onApplicationEvent()

ServiceBean.onApplicationEvent():

onApplicationEvent()：根据服务export发布状态，判断是否export()

    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (!isExported() && !isUnexported()) {
            if (logger.isInfoEnabled()) {
                logger.info("The service ready on spring started. service: " + getInterface());
            }
            export();
        }
    }

ServiceBean.export():

export方法做了两件事

  1. 调用父类的export()，父类为ServiceConfig， ServiceBean#export()->ServiceConfig#export()
  2. 发布ExportEvent
    public void export() {
        // Step1
        super.export();
        // Step2
        publishExportEvent();
    }

super.export():

Step1：super.export() => ServiceConfig#export()

  1. 配置检查和更新事先由afterPropertiesSet()配置完毕
  2. 判断是否需要导出，不导出就是本地方法
  3. 若延迟导出则委托delayExecutor执行导出
  4. 否则调用 doExport()
package org.apache.dubbo.config;
super class ServiceConfig
public synchronized void export() {
        // 配置检查和更新 事先由afterPropertiesSet配置完毕
        checkAndUpdateSubConfigs();
        if (!shouldExport()) { // 标签属性export boolean
            return;
        }
        if (shouldDelay()) {// 标签属性delay boolean
            // 延时export
            delayExecutor.schedule(this::doExport, getDelay(), MILLISECONDS);
        } else {
            doExport();
        }
    }

super.doExportUrls():

doExport()在简单开关验证及设置path=interfaceName之后执行doExportUrls()

doExportUrls():

  1. 获取注册中心URL地址，由上面标签定义，此处已知配置为multicast

  2. 获取协议列表，一般只配置一个protocol，由标签定义

  3. 开始循环协议列表

    获取pathKey：com.kaiyuan.qyd.topic.dubbo.basic.DemoService

    创建ProviderModel实体对象并加入缓存，interfaceClass是接口类，ref是接口实现类

    执行核心逻辑doExportUrlsFor1Protocol()

package org.apache.dubbo.config;
super class ServiceConfig
private void doExportUrls() {
        // registry://host/org.xxx.registry.RegistryService?application=demo-provider®istry=multicast
        List registryURLs = loadRegistries(true);
        // 
        for (ProtocolConfig protocolConfig : protocols) {
            // pathKey = com.kaiyuan.qyd.topic.dubbo.basic.DemoService
            String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
            // interfaceClass是接口类，ref是接口实现类
            ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
            // 放入缓存PROVIDED_SERVICES
            ApplicationModel.initProviderModel(pathKey, providerModel);
            // 核心代码
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

AbstractInterfaceConfig.loadRegistries():

这个方法来自抽象父类，主要逻辑为：

1.参数验证，代码中省略

2.根据BeanDefinition配置，获取parameters放到map中

3.根据map中的参数生成注册中心URL地址，翻译如下：

registry://host/org.xxx.RegistryService?application=demo-provider®istry=multicast

   protected List loadRegistries(boolean provider) {
      List registryList = new ArrayList();
      // 省略参数验证
            if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
             Map map = new HashMap();
         // 把中的parameter放到map中，比如name
             appendParameters(map, application);
         // 把中的parameter反射放到map中，比如host
             appendParameters(map, config);
             map.put(PATH_KEY, RegistryService.class.getName());
         // 追加一些运行时参数比如时间戳，版本号，pid
             appendRuntimeParameters(map);
             List urls = UrlUtils.parseURLs(address, map);
             for (URL url : urls) {
                 url = URLBuilder.from(url)
                         .addParameter(REGISTRY_KEY, url.getProtocol())
                         .setProtocol(REGISTRY_PROTOCOL)
                         .build();
             // registry://host/org.xxx.RegistryService?application=demo-provider®istry=multicast
                 if ((provider && url.getParameter(REGISTER_KEY, true))
                         || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) {
                     registryList.add(url);
                 }
             }
            }
      return registryList;
    }

appendParameters()

看下参数追加的代码逻辑

1.获取当前BeanDefinition所配置的所有Getter方法，本例是application的getApplication()

2.反射获取getApplication()的注解修饰类，判断是否被@Parameter(excluded = true)修饰跳出设置，否则追加到parameters

    protected static void appendParameters(Map parameters, Object config, String prefix) {
        Method[] methods = config.getClass().getMethods();
        for (Method method : methods) {
            try {
                String name = method.getName();
                // 获取ApplicationConfig下所有的Getter方法：getApplication()
                if (MethodUtils.isGetter(method)) {//getName()
                    Parameter parameter = method.getAnnotation(Parameter.class);
                    if (method.getReturnType() == Object.class || parameter != null && parameter.excluded()) {
                        continue;
                    }
                } 
                // put parameters key：prefix.xxx ....
            } catch (Exception e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
        }
    }

super.doExportUrlsFor1Protocol():

服务发布核心代码，比较长，不适合阅读，所以拆分成四块分析

1.根据BeanDefinition配置组装URL

    private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
        String name = protocolConfig.getName();
        if (StringUtils.isEmpty(name)) {
            name = DUBBO;
        }
        Map map = new HashMap();
        // 标记为Provider端
        map.put(SIDE_KEY, PROVIDER_SIDE);
        // 追加一些运行时参数比如时间戳，版本号，pid
        appendRuntimeParameters(map);
        // 把BeanDefinition中的parameter反射放到map中
        appendParameters(map, metrics);
        appendParameters(map, application);
        appendParameters(map, module);
        appendParameters(map, provider);
        appendParameters(map, protocolConfig);
        appendParameters(map, this);
        // 子标签配置
    }

此时的map是这样的:

{
    "side": "provider", // 标记为生产者
    "application": "demo-provider",
    "release": "2.7.2", // 从jar包截取的版本号
    "deprecated": "false",
    "dubbo": "2.0.2", // Dubbo RPC protocol version
    "pid": "48180",
    "dynamic": "true",
    "interface": "com.kaiyuan.qyd.topic.dubbo.basic.DemoService",
    "generic": "false", // 是否是泛化调用
    "timestamp": "1563865286121", // 时间戳
    "register": "true",
    "bean.name": "com.kaiyuan.qyd.topic.dubbo.basic.DemoService"
}

2.子标签配置，配置粒度可以到级别，跟踪这段代码需要补充配置标签：

细粒度的配置主要用来为泛化调用，区分参数类型，参数下标，正常业务很少对它配置

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
      // 判断是否配置
            if (CollectionUtils.isNotEmpty(methods)) {
            for (MethodConfig method : methods) {
                // 追加timeout参数到map中，key：sayHello.timeout value:2000
                appendParameters(map, method, method.getName());
                // 判断是否设置sayHello.retry或重写retries
                String retryKey = method.getName() + ".retry";
                if (map.containsKey(retryKey)) {
                    String retryValue = map.remove(retryKey);
                    if ("false".equals(retryValue)) {
                        map.put(method.getName() + ".retries", "0");
                    }
                }
                List arguments = method.getArguments();
                // 是否配置了，列表判断是因为参数可能多参
                if (CollectionUtils.isNotEmpty(arguments)) {
                    // 省略的这部分代码主要是配置和上面的逻辑相同
                }
            } // end of methods for
        }
}

配置完 ，map变成这样：

{
    ... // 省略未变化参数
    "sayHello.timeout": "2000", // 方法的超时时间
    "sayHello.0.callback": "true" // 标记下标为0的参数是callback函数（举例而已）
}

3.判断是否是泛化调用，并追加一些参数到map中，生成URL对象

这里有个特殊的Wrapper，javassist处理后自动生成getMethodNames()，留在Invoke章节详细介绍

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
      // 是否泛化调用，本例是用户业务接口，不是泛化调用接口
            if (ProtocolUtils.isGeneric(generic)) {
            map.put(GENERIC_KEY, generic);
            map.put(METHODS_KEY, ANY_VALUE);
        } else {
            String revision = Version.getVersion(interfaceClass, version);
            if (revision != null && revision.length() > 0) {
                map.put(REVISION_KEY, revision);
            }
                // 包装类，javassist处理之后自动生成getMethodNames(),Invoker章节详细介绍
            String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
            if (methods.length == 0) {
                logger.warn("No method found in service interface " + interfaceClass.getName());
                map.put(METHODS_KEY, ANY_VALUE);
            } else {
                map.put(METHODS_KEY, StringUtils.join(new HashSet(Arrays.asList(methods)), ","));
            }
        }
        // 是否配置token
        if (!ConfigUtils.isEmpty(token)) {
            if (ConfigUtils.isDefault(token)) {
                map.put(TOKEN_KEY, UUID.randomUUID().toString());
            } else {
                map.put(TOKEN_KEY, token);
            }
        }
            // 获取本地ip
        String host = this.findConfigedHosts(protocolConfig, registryURLs, map);
        // port:20880
        Integer port = this.findConfigedPorts(protocolConfig, name, map);
            // 由map对象转换生成url
        URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);
        // export service ...
}

url由map对象转换而成:

dubbo://172.16.69.49:20880/com.kaiyuan.qyd.topic.dubbo.basic.DemoService?anyhost=true&application=demo-provider&bean.name=com.kaiyuan.qyd.topic.dubbo.basic.DemoService&bind.ip=172.16.69.49&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.kaiyuan.qyd.topic.dubbo.basic.DemoService&methods=sayHello&pid=46800®ister=true&release=2.7.2&sayHello.0.callback=true&sayHello.timeout=2000&side=provider×tamp=1563870489213

4.服务发布，涉及RPC模块的内容，将在第三章Invoker详细介绍，这里需要了解Dubbo的领域模型

  • 实体域：Invoker，是RPC调用的核心

  • 会话域：Invocation，一次RPC调用的上下文

  • 服务域：Protocol，实体域会话域生命周期管理，发布或引用入口

package org.apache.dubbo.rpc;
@SPI("dubbo")
// 服务域
public interface Protocol { 
    int getDefaultPort();
    @Adaptive
     Exporter export(Invoker invoker) throws RpcException;
    @Adaptive
     Invoker refer(Class type, URL url) throws RpcException;
}
// 实体域
public interface Invoker extends Node {
    Class getInterface();
    Result invoke(Invocation invocation) throws RpcException;
}
// 会话域
public interface Invocation {
    String getMethodName();
    Class[] getParameterTypes();
    Object[] getArguments();
    Map getAttachments();
    void setAttachment(String key, String value);
    void setAttachmentIfAbsent(String key, String value);
    String getAttachment(String key);
    String getAttachment(String key, String defaultValue);
    Invoker getInvoker();
}

服务发布逻辑：

1.判断协议是否被重新定义

2.本地服务发布：url重写，创建Invoker动态代理类，缓存Exporter等待export()

3.远程服务发布：和本地调用一样先生成Exporter后执行export()，开启远程端口，注册dubbo协议到注册中心等待调用

package org.apache.dubbo.config;

public class ServiceConfig extends AbstractServiceConfig {
        private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

    private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
            // 判断dubbo协议是否被用户自定义，此处使用默认dubbo协议
            if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                    .hasExtension(url.getProtocol())) {
                url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                        .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
            }
            // url中没有配置scope，此处为null
            String scope = url.getParameter(SCOPE_KEY);
            // don't export when none is configured
            if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
                if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
                    // 先从本地export
                    exportLocal(url);
                }
                // 如果配置了注册中心则进行远程export 
                // 1.createExporter(ref,interface,register)
                // 2.register("dubbo://xxx")
                // 3.openServer(url);
            }
    }
  
    private void exportLocal(URL url) {
        // url host port重写变成injvm://127.0.0.1,其他参数未变
        URL local = URLBuilder.from(url)
                .setProtocol(LOCAL_PROTOCOL)
                .setHost(LOCALHOST_VALUE)
                .setPort(0)
                .build();
        // 包装ref引用为Invoker接口对象，执行protocol.export()
        Exporter exporter = protocol.export(
                proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
        // 加入缓存
        exporters.add(exporter);
    }
}

小结：方法export()概括的说做了两件事

  1. 配置URL，生成Protocol服务域。dubbo协议是register协议的一个export参数同步到注册中心

    registry://host/xxx.RegistryService?export=dubbo%3A%2F%2F172.16.69.49%3A20880%2F/xxx

  2. 生成远程代理类Invoker，执行Protocol.export(Invoker)，注册服务，开启端口监听，等待Protocol.refer()

ServiceBean.export()方法Step2执行publishExportEvent()，发布一个事件，下面看下具体逻辑

Step2：publishExportEvent()

  1. 创建ServiceBeanExportedEvent事件，此对象结构比较简单，只有一个构造参数source
  2. source对象代表发生事件的主体，继承自Spring的ApplicationEvent，source=ServiceBean(this)
  3. 调用spring注入applicationEventPublisher发布事件等待监听器响应
public void export() {
   // Step1
   super.export();
   // Step2
   publishExportEvent();
}
  
private void publishExportEvent() {
   // 创建事件实体对象，source对象为ServiceBean
   ServiceBeanExportedEvent exportEvent = new ServiceBeanExportedEvent(this);
   // ApplicationEventPublisherAware方法注入的Publisher
   applicationEventPublisher.publishEvent(exportEvent);
}

ReferenceAnnotationBeanPostProcessor

ServiceBeanExportedEvent事件只有一个监听Listener即ReferenceAnnotationBeanPostProcessor，该类结构如下：

package org.apache.dubbo.config.spring.beans.factory.annotation;
public class ReferenceAnnotationBeanPostProcessor
    extends AnnotationInjectedBeanPostProcessor
    implements ApplicationContextAware, ApplicationListener
接口 方法 作用
ApplicationContextAware setApplicationContext() Spring上下文
ApplicationListener onApplicationEvent(E event) 监听逻辑
AnnotationInjectedBeanPostProcessor doGetInjectedBean（...） 注解依赖注入
  1. ApplicationListener，监听ServiceBeanExportedEvent，执行onApplicationEvent()
  2. AnnotationInjectedBeanPostProcessor，dubbo的依赖注入工具与spring注入对接

先看ApplicationListener唯一方法onApplicationEvent()，事件的执行者

onApplicationEvent()

  1. 判断instanceof ServiceBeanExportedEvent
  2. 执行onServiceBeanExportEvent(event)
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ServiceBeanExportedEvent) {
            // 判断类型执行相应操作 内部直接调用了initReferenceBeanInvocationHandler方法
            onServiceBeanExportEvent((ServiceBeanExportedEvent) event);
        } else if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        }
  }

在onServiceBeanExportEvent()内部直接调用了initReferenceBeanInvocationHandler()

initReferenceBeanInvocationHandler()

  1. 获取cache key
  2. 从localReferenceBeanInvocationHandlerCache中移除了key对象
  3. 执行了init()
 private void initReferenceBeanInvocationHandler(ServiceBean serviceBean) {
        String beanName = serviceBean.getBeanName();
        // Remove ServiceBean when it's exported
        // 为了调整格式修改了变量名称lrbhc=localReferenceBeanHandlerCache
        ReferenceBeanInvocationHandler handler = lrbhc.remove(beanName);
        // Initialize
        if (handler != null) {
            handler.init();
        }
 }

问题：为什么要用缓存？

因为和都是重量级对象，不能频繁创建，缓存和双重锁保证单例
dubbo依托spring生命周期做缓存证明了dubbo使用api启动的方式要考虑程序健壮性，需要自己做内存管理

问题： 为什么要从localReferenceBeanHandlerCache中移除对象？

带着这个问题继续分析，cache可以被remove说明cache里面有值，如果我们知道缓存存放的是什么值，以及存放的逻辑，那么也就知道问题所在了。

按照这个思路定位到方法doGetInjectedBean()，是来自父类AnnotationInjectedBeanPostProcessor的抽象方法，该方法有个关键的参数

 Object doGetInjectedBean(Reference reference, Object bean, String beanName,Class injectedType,InjectedElement injectedElement)

Reference reference： 这是我们@Reference 的注解类，通过它可以注入SpringBean，通常这么写

package com.kaiyuan.qyd.business.tx;
@Reference FooService fooService;

Dubbo依托Spring包扫描机制把@Service/@Reference注解修饰的对象注册/注入到Spring容器中

@Reference使用范围：可以用在Field，Method上，说明是用来依赖注入

package org.apache.dubbo.config.annotation;
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Reference {}

@Service的使用范围：只能用在Class上为了注册到spring容器

package org.apache.dubbo.config.annotation;
@Target({ElementType.TYPE})
public @interface Service {}

DubboComponentScanRegistrar:

上面说到Dubbo依托Spring包扫描机制把@Service/@Reference注解修饰的对象注册/注入到Spring容器中，下面简单介绍下是怎么实现的

父类ImportBeanDefinitionRegistrar是Spring接口，用来实现包扫描注册功能

  1. @DubboComponentScan包扫描获取路径
  2. 注册@Service注解修饰的对象到spring，会触发BeanDefinition拦截器自定义注入逻辑
  3. 注入@Reference注解修饰的对象到spring，最终会触发依赖注入doGetInjectedBean逻辑 
package org.apache.dubbo.config.spring.context.annotation;
// 本节只做介绍后面会有spring和dubbo整合的源码分析
public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {
@Override
void registerBeanDefinitions(AnnotationMetadata meta, BeanDefinitionRegistry registry) {
       // @DubboComponentScan包扫描
     Set packagesToScan = getPackagesToScan(meta);
     // 注册@Service注解修饰的对象到spring，使用了BeanDefinitionRegistry注册工厂
     // 核心逻辑在ServiceAnnotationBeanPostProcessor.registerServiceBean方法内部
     registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
     // 注入@Reference注解修饰的对象到spring，使用了BeanDefinitionRegistry注册工厂
     registerReferenceAnnotationBeanPostProcessor(registry);
 }
}

Spring所使用的注册工厂如下，registerBeanDefinition()执行注册逻辑时会触发Dubbo实现的BeanDefinitionRegistryPostProcessor子类ServiceAnnotationBeanPostProcessor实现自定义注册

package org.springframework.beans.factory.support;
public interface BeanDefinitionRegistry extends AliasRegistry {
    // spring注册方法
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

doGetInjectedBean
上面说到使用@Reference依赖注入最终会执行本方法，下面开始分析方法逻辑

doGetInjectedBean

  1. 获取referencedBeanName
  2. 包装业务接口成ReferenceBean
  3. 缓存ReferenceBean到BeanCache
  4. 创建代理类
 @Override
 Object doGetInjectedBean(Reference reference, Object bean, String beanName,Class injectedType,InjectedElement injectedElement){
     // 构建beanname
     String referencedBeanName = buildReferencedBeanName(reference, injectedType);
     // 包装业务接口成ReferenceBean
     ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referencedBeanName,reference, injectedType, getClassLoader());
     cacheInjectedReferenceBean(referenceBean, injectedElement);
     // 创建代理类 
     return buildProxy(referencedBeanName, referenceBean, injectedType);
 }

动态代理在这里的作用是动态生成代理类,对原始方法进行控制，对使用者透明，本章只阐述下直观作用

未代理之前：
调用方->业务接口->业务接口实现类
动态代理后：
调用方->业务接口->动态代理类->业务接口实现类

动态代理类InvocationHandler.invoke()方法示例：

begin()
 try 
  action1
        srcMethod.invoke();// 原始方法调用
    action2
 catch e {}
 finally {}
end()

真实的代理比这个要复杂，本代理类其实就是远程调用的Invoker对象(包含五元组，协议，序列化等等)，比如consumer端执行远程调用的同时也要生成代理类，provider端接收亦然,在后面章节Invoker和Proxy会详细介绍

buildProxy：

介绍完动态代理，回过头来看下代码逻辑

buildProxy目的是针对业务接口生成代理方法，对调用方无感知

Object buildProxy(String referencedBeanName, ReferenceBean referenceBean, Class injectedType) {
                // 生成动态代理handler,对业务接口进行控制代理
        InvocationHandler handler = buildInvocationHandler(referencedBeanName, referenceBean);
        // dubbo注解管理的bean对象都是动态代理类，会执行handler.invoke()
        return Proxy.newProxyInstance(getClassLoader(), new Class[]{injectedType}, handler);
}

问题的线索就在buildInvocationHandler()内部

缓存存放的值：ReferenceBeanInvocationHandler，该对象是上面的动态代理类
缓存存放逻辑：@Reference注入的是不是本地@Service注册的Spring对象

InvocationHandler buildInvocationHandler(String referencedBeanName, ReferenceBean referenceBean) {
        ReferenceBeanInvocationHandler handler = lcrih.get(referencedBeanName);
        if (handler == null) {
            handler = new ReferenceBeanInvocationHandler(referenceBean);
        }
        // 从这能看到缓存添加的是本地spring管理的bean对象,用referencedBeanName做区分
        if (applicationContext.containsBean(referencedBeanName)) { 
            // lcrih=localReferenceBeanInvocationHandlerCache
            lcrih.put(referencedBeanName, handler);
        } else {
            handler.init();
        }
        return handler;
}

ReferenceBeanInvocationHandler

ReferenceBeanInvocationHandler继承了InvocationHandler动态代理类，代理对象是业务定义的接口：

方法逻辑很简单，只是从缓存中获取管理的ReferenceBean调用执行，同时解决了一个单元测试的bug：

package org.apache.dubbo.config.spring.beans.factory.annotation;
public class ReferenceAnnotationBeanPostProcessor {}
// static内部类
private static class ReferenceBeanInvocationHandler implements InvocationHandler {
        private final ReferenceBean referenceBean;
        private Object bean;
        private ReferenceBeanInvocationHandler(ReferenceBean referenceBean) {
            this.referenceBean = referenceBean;
        }

        @Override // 动态代理方法执行入口
        public Object invoke(Object proxy, Method method, Object[] args) {
            Object result;
            try {
                if (bean == null) { 
                    // issue: https://github.com/apache/dubbo/issues/3429
                    init();
                }
                result = method.invoke(bean, args);
            } catch (InvocationTargetException e) {
                // re-throws the actual Exception.
                throw e.getTargetException();
            }
            return result;
        }
    
        private void init() {
            this.bean = referenceBean.get();
        }
    }
}

小结：

  1. 当ServiceBean执行export方法时发布ServiceBeanExportedEvent事件
  2. ReferenceAnnotationBeanPostProcessor监听到该事件，从本地localReferenceBeanInvocationHandlerCache缓存中移除bean对象
  3. 缓存中的数据是依托DubboComponentScan包扫描机制根据@Service注解注入到spring容器中，同时对@Reference进行依赖注入
  4. 如果ReferenceBean所代理的bean其实是本地spring容器管理的，也就是本地调用，则存放到localReferenceBeanInvocationHandlerCache中
  5. 因为有延迟导出的存在，所以采用事件通知机制及时更新本地缓存，动态代理生成InvocationHandler对象
  6. localReferenceBeanInvocationHandlerCache移除的只是本地代理对象，真正的远程代理类都在referenceBeanCache里面保存着

服务引用

服务发布完成后，生成RPC代理，同步Invoker信息到注册中心，等待Consumer端引用，配置如下:

ReferenceBean

Dubbo要求标签由Consumer端定义，下面开始介绍Consumer的定义入口ReferenceBean。

public class ReferenceBean extends ReferenceConfig 
    implements FactoryBean, ApplicationContextAware, 
                         InitializingBean, DisposableBean {}
接口 方法 作用
FactoryBean getObject() 获取spring对象
ApplicationContextAware setApplicationContext(ApplicationContext) 注入spring环境
InitializingBean afterPropertiesSet() bean启动扩展
DisposableBean destroy() bean销毁扩展

这个类实现的接口与ServiceBean类似，相同的地方无需赘述，区别在于FactoryBean.getObject()

Spring容器启动自动调用afterPropertiesSet()，进行一系列的BeanDefinition设置之后执行FactoryBean.getObject()

package org.apache.dubbo.config.spring;

public class ReferenceBean extends ReferenceConfig
implements FactoryBean, ApplicationContextAware,
                     InitializingBean, DisposableBean {}

public void afterPropertiesSet() throws Exception {
    // 执行一系列BeanDefinition配置
    // setConsumer()
    // setApplication()
    // setRegistries()
    if (shouldInit()) {// 是否延迟加载
        getObject();
    }
}

public Object getObject() {
    // 父类ReferenceConfig中的方法
    return get();
}

ReferenceConfig.get():

同步方法get()和非空判断保证了单例，内部逻辑先是做了内部的验证和默认配置重写，之后执行ReferenceConfig.init()

package org.apache.dubbo.config;
public class ReferenceConfig {
  
  public synchronized T get() {
      // 内部验证比如注册中心，还有一些默认参数的重写
      checkAndUpdateSubConfigs();

      if (destroyed) {
          throw new IllegalStateException("The invoker has already destroyed!");
      }
      if (ref == null) {
          // 单例初始化
          init();
      }
      return ref;
  }
}

ReferenceConfig.init():

核心是从注册中心获取元数据创建代理类，细节会在Invoker里面详细介绍

1.例行参数检查

2.map对象参数设置

2.创建远程代理类

private void init() {
    if (initialized) {
        return;
    }
    // 例行检查
    checkStubAndLocal(interfaceClass);
    checkMock(interfaceClass);
    Map map = new HashMap();
    map.put(SIDE_KEY, CONSUMER_SIDE);
    appendRuntimeParameters(map);
    // 省略map参数准备...
    String hostToRegistry = ConfigUtils.getSystemProperty(DUBBO_IP_TO_REGISTRY);
    if (StringUtils.isEmpty(hostToRegistry)) {
        hostToRegistry = NetUtils.getLocalHost();
    } else if (isInvalidLocalHost(hostToRegistry)) {
        throw new IllegalArgumentException("Specified invalid registry ip from property:");
    }
    map.put(REGISTER_IP_KEY, hostToRegistry);
        // 从注册中心获取元数据创建远程调用代理类
    ref = createProxy(map);
    String serviceKey = URL.buildKey(interfaceName, group, version);
    // 创建ConsumerModel并放到ApplicationModel缓存里
    ApplicationModel.initConsumerModel(serviceKey, buildConsumerModel(serviceKey, attributes));
    initialized = true;
}

小结：

ServiceConfig和ReferenceConfig最终都指向了Invoker，也说明了实体域Invoker的重要性，在这里对两个重要方法做个标记，也是后面第三章的引子。

1.服务发布创建远程代理类：ServiceConfig.doExportUrlsFor1Protocol()

2.服务导出引用远程代理类：ReferenceConfig.init()

你可能感兴趣的:(【Dubbo】2.服务发布和引用)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 放下是一段成长的修行 小莳玥
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 数据采集高并发的架构应用 3golden .net
    问题的出发点：          最近公司为了发展需要，要扩大对用户的信息采集，每个用户的采集量估计约2W。如果用户量增加的话，将会大量照成采集量成3W倍的增长，但是又要满足日常业务需要，特别是指令要及时得到响应的频率次数远大于预期。       &n
  • 不停止 MySQL 服务增加从库的两种方式 brotherlamp linuxlinux视频linux资料linux教程linux自学
    现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。  一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabacku
  • Quartz——SimpleTrigger触发器 eksliang SimpleTriggerTriggerUtilsquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208166 一.概述 SimpleTrigger触发器，当且仅需触发一次或者以固定时间间隔周期触发执行；   二.SimpleTrigger的构造函数 SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称； Simpl
  • Informatica应用（1） 18289753290 sqlworkflowlookup组件Informatica
    1.如果要在workflow中调用shell脚本有一个command组件，在里面设置shell的路径；调度wf可以右键出现schedule，现在用的是HP的tidal调度wf的执行。 2.designer里面的router类似于SSIS中的broadcast（多播组件）;Reset_Workflow_Var：参数重置 （比如说我这个参数初始是1在workflow跑得过程中变成了3我要在结束时还要
  • python 获取图片验证码中文字 酷的飞上天空 python
    根据现成的开源项目 http://code.google.com/p/pytesser/改写 在window上用easy_install安装不上  看了下源码发现代码很少  于是就想自己改写一下   添加支持网络图片的直接解析   #coding:utf-8 #import sys #reload(sys) #sys.s
  • AJAX 永夜-极光 Ajax
    1.AJAX功能:动态更新页面,减少流量消耗,减轻服务器负担   2.代码结构:    <html> <head> <script type="text/javascript"> function loadXMLDoc() { .... AJAX script goes here ...
  • 创业OR读研 随便小屋 创业
            现在研一，有种想创业的想法，不知道该不该去实施。因为对于的我情况这两者是矛盾的，可能就是鱼与熊掌不能兼得。                研一的生活刚刚过去两个月，我们学校主要的是
  • 需求做得好与坏直接关系着程序员生活质量 aijuans IT 生活
            这个故事还得从去年换工作的事情说起，由于自己不太喜欢第一家公司的环境我选择了换一份工作。去年九月份我入职现在的这家公司，专门从事金融业内软件的开发。十一月份我们整个项目组前往北京做现场开发，从此苦逼的日子开始了。        系统背景：五月份就有同事前往甲方了解需求一直到6月份，后续几个月也完
  • 如何定义和区分高级软件开发工程师 aoyouzi
    在软件开发领域，高级开发工程师通常是指那些编写代码超过 3 年的人。这些人可能会被放到领导的位置，但经常会产生非常糟糕的结果。Matt Briggs 是一名高级开发工程师兼 Scrum 管理员。他认为，单纯使用年限来划分开发人员存在问题，两个同样具有 10 年开发经验的开发人员可能大不相同。近日，他发表了一篇博文，根据开发者所能发挥的作用划分软件开发工程师的成长阶段。 　　初
  • Servlet的请求与响应 百合不是茶 servletget提交java处理post提交
      Servlet是tomcat中的一个重要组成,也是负责客户端和服务端的中介     1,Http的请求方式(get  ,post);   客户端的请求一般都会都是Servlet来接受的,在接收之前怎么来确定是那种方式提交的,以及如何反馈,Servlet中有相应的方法,  http的get方式 servlet就是都doGet(
  • web.xml配置详解之listener bijian1013 javaweb.xmllistener
    一.定义 <listener> <listen-class>com.myapp.MyListener</listen-class> </listener>   二.作用        该元素用来注册一个监听器类。可以收到事件什么时候发生以及用什么作为响
  • Web页面性能优化（yahoo技术） Bill_chen JavaScriptAjaxWebcssYahoo
    1.尽可能的减少HTTP请求数 content 2.使用CDN server 3.添加Expires头(或者 Cache-control) server 4.Gzip 组件 server 5.把CSS样式放在页面的上方。 css 6.将脚本放在底部(包括内联的) javascript 7.避免在CSS中使用Expressions css 8.将javascript和css独立成外部文
  • 【MongoDB学习笔记八】MongoDB游标、分页查询、查询结果排序 bit1129 mongodb
    游标   游标，简单的说就是一个查询结果的指针。游标作为数据库的一个对象，使用它是包括 声明 打开 循环抓去一定数目的文档直到结果集中的所有文档已经抓取完 关闭游标   游标的基本用法，类似于JDBC的ResultSet(hasNext判断是否抓去完,next移动游标到下一条文档)，在获取一个文档集时，可以提供一个类似JDBC的FetchSize
  • ORA-12514 TNS 监听程序当前无法识别连接描述符中请求服务 的解决方法 白糖_ ORA-12514
    今天通过Oracle SQL*Plus连接远端服务器的时候提示“监听程序当前无法识别连接描述符中请求服务”，遂在网上找到了解决方案： ①打开Oracle服务器安装目录\NETWORK\ADMIN\listener.ora文件，你会看到如下信息：   # listener.ora Network Configuration File: D:\database\Oracle\net
  • Eclipse 问题 A resource exists with a different case bozch eclipse
    在使用Eclipse进行开发的时候，出现了如下的问题： Description Resource Path Location TypeThe project was not built due to "A resource exists with a different case: '/SeenTaoImp_zhV2/bin/seentao'.&
  • 编程之美-小飞的电梯调度算法 bylijinnan 编程之美
    public class AptElevator { /** * 编程之美 小飞 电梯调度算法 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己的目的层。 * 在一楼时，每个乘客选择自己的目的层，电梯则自动计算出应停的楼层。 * 问：电梯停在哪
  • SQL注入相关概念 chenbowen00 sqlWeb安全
    SQL Injection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。 具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 首先让我们了解什么时候可能发生SQ
  • [光与电]光子信号战防御原理 comsci 原理
          无论是在战场上,还是在后方,敌人都有可能用光子信号对人体进行控制和攻击,那么采取什么样的防御方法,最简单,最有效呢?       我们这里有几个山寨的办法,可能有些作用,大家如果有兴趣可以去实验一下       根据光
  • oracle 11g新特性:Pending Statistics daizj oracledbms_stats
    oracle 11g新特性:Pending Statistics 转 从11g开始，表与索引的统计信息收集完毕后，可以选择收集的统信息立即发布，也可以选择使新收集的统计信息处于pending状态，待确定处于pending状态的统计信息是安全的，再使处于pending状态的统计信息发布，这样就会避免一些因为收集统计信息立即发布而导致SQL执行计划走错的灾难。 在 11g 之前的版本中，D
  • 快速理解RequireJs dengkane jqueryrequirejs
    RequireJs已经流行很久了，我们在项目中也打算使用它。它提供了以下功能： 声明不同js文件之间的依赖 可以按需、并行、延时载入js库 可以让我们的代码以模块化的方式组织 初看起来并不复杂。 在html中引入requirejs 在HTML中，添加这样的 <script> 标签： <script src="/path/to
  • C语言学习四流程控制if条件选择、for循环和强制类型转换 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i, j; scanf("%d %d", &i, &j); if (i > j) printf("i大于j\n"); else printf("i小于j\n"); retu
  • dictionary的使用要注意 dcj3sjt126com IO
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys: user.user_id , @"id", user.username , @"username",
  • Android 中的资源访问(Resource) finally_m xmlandroidStringdrawablecolor
    简单的说，Android中的资源是指非代码部分。例如，在我们的Android程序中要使用一些图片来设置界面，要使用一些音频文件来设置铃声，要使用一些动画来显示特效，要使用一些字符串来显示提示信息。那么，这些图片、音频、动画和字符串等叫做Android中的资源文件。 在Eclipse创建的工程中，我们可以看到res和assets两个文件夹，是用来保存资源文件的，在assets中保存的一般是原生
  • Spring使用Cache、整合Ehcache 234390216 springcacheehcache@Cacheable
    Spring使用Cache            从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的
  • 当druid遇上oracle blob(clob) jackyrong oracle
    http://blog.csdn.net/renfufei/article/details/44887371 众所周知，Oracle有很多坑, 所以才有了去IOE。 在使用Druid做数据库连接池后，其实偶尔也会碰到小坑，这就是使用开源项目所必须去填平的。【如果使用不开源的产品，那就不是坑，而是陷阱了，你都不知道怎么去填坑】 用Druid连接池，通过JDBC往Oracle数据库的
  • easyui datagrid pagination获得分页页码、总页数等信息 ldzyz007
    var grid = $('#datagrid');  var options = grid.datagrid('getPager').data("pagination").options;  var curr = options.pageNumber;  var total = options.total;  var max =
  • 浅析awk里的数组 nigelzeng 二维数组array数组awk
    awk绝对是文本处理中的神器，它本身也是一门编程语言，还有许多功能本人没有使用到。这篇文章就单单针对awk里的数组来进行讨论，如何利用数组来帮助完成文本分析。   有这么一组数据：   abcd,91#31#2012-12-31 11:24:00 case_a,136#19#2012-12-31 11:24:00 case_a,136#23#2012-12-31 1
  • 搭建 CentOS 6 服务器(6) - TigerVNC rensanning centos
    安装GNOME桌面环境 # yum groupinstall "X Window System" "Desktop" 安装TigerVNC # yum -y install tigervnc-server tigervnc 启动VNC服务 # /etc/init.d/vncserver restart # vncser
  • Spring 数据库连接整理 tomcat_oracle springbeanjdbc
    1、数据库连接jdbc.properties配置详解 　　jdbc.url=jdbc:hsqldb:hsql://localhost/xdb 　　jdbc.username=sa 　　jdbc.password= 　　jdbc.driver=不同的数据库厂商驱动，此处不一一列举 　　接下来，详细配置代码如下： 　　 Spring连接池    
  • Dom4J解析使用xpath java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常 xp9802
    用Dom4J解析xml,以前没注意,今天使用dom4j包解析xml时在xpath使用处报错      异常栈：java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常       导入包 jaxen-1.1-beta-6.jar 解决; &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他