必逍遥
必逍遥

【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.服务发布和引用)

  • BIM的认识 MeiLinR
    BIM系列的软件呈现出的是一个三维的立体图，可以很形象的反映出建筑物的形状、体貌等特征，让大家对建筑物有直观上的认识，而不是靠对CAD图纸的认识去想象。具有以下特点一、可视化BIM技术可事先模拟，以及可视化和标准化的特性，让多方在项目内容的理解上更加透彻和一致，便于提前发现问题，做出精细安排。二、一体化BIM技术可进行从设计到施工再到运营贯穿了工程项目的全生命周期的一体化管理。BIM能在综合数字环
  • 为什么需要对即将上线的系统进行压力测试 群联云防护小杜 安全问题汇总压力测试python开发语言网络网络协议爬虫ddos
    摘要本文将探讨为什么在系统上线前进行压力测试至关重要。我们将通过具体的案例和代码示例来说明压力测试的重要性，并介绍如何执行基本的压力测试。1.引言在软件开发周期中，压力测试是一项关键的质量保证措施。它可以帮助开发者和运维人员评估系统的稳定性和性能极限，在系统正式部署之前识别并修复潜在问题。本文将重点讨论压力测试的重要性，并提供一些实用的指南。2.什么是压力测试压力测试是一种软件测试类型，旨在确定系
  • 盲人摸象的故事/第99个故事 韩玲Julie
    从前，有五个盲人，从来没有见过大象，不知道大象长的什么样，他们就决定去摸摸大象。第一个人摸到了鼻子，他说：“大象像一条弯弯的管子。”第二个人摸到了尾巴，他说：“大象像个细细的棍子。”第三个人摸到了身体，他说：“大象像一堵墙。”第四个人摸到了腿，他说：“大象像一根粗粗的柱子。”盲人摸象的寓言含义:看事情要全面,整体,不要分割开来.坚信自己的观点和坚持自己的观点很重要,,学会听别人的观点,会把事情了解
  • 招聘人才哪家好？求职工作哪家才是靠谱的平台？二者兼得看这里 配音就业圈
    人才招聘去哪里找？求职高岗位去哪家平台？还在大海捞针似的找工作？这些快捷方式你知道吗？这些找工作的小技巧你知道吗？兼职副业推荐公众号，配音新手圈，声优配音圈，新配音兼职圈，配音就业圈，鼎音副业，有声新手圈，每天更新各种远程工作与在线兼职，职位包括：写手、程序开发、剪辑、设计、翻译、配音、无门槛、插画、翻译、等等。。。每日更新兼职。智联、前程和58这些招聘平台都是一些老牌人才招聘网站，有大量的用户群
  • 系统开发压力测试高并发 朱杰jjj java压力测试json大数据
    目的：压力测试软景见环境下的系统多能承受的最大负荷以及高访问量出现的并发带来的问题。压力测试能够帮助系统在线上稳定持续的运行，在一定范围内可以做到心中有数。我们希望压力测试能够发现更多的错误。其中两种：并发同步问题、内存泄漏问题。性能指标1.响应时间（RT）:指从客户端发起一个请求开始到客户端接收到服务端返回的响应结束的整个过程所耗费的时间。2.HPS：每秒点击次数。3.TPS：系统每秒处理交易的
  • Android wifi主要广播详解 峥嵘life androidAndroid网络android网络
    Androidwifi相关主要广播总结文章目录Androidwifi相关主要广播总结一、前言二、wifi主要广播分析介绍1、简单的广播监听2、wifi广播对应的action字符串：3、广播和接收的相关数据三、广播相关日志：1、wifi扫描广播的日志2、wifi连接、断开的日志（1）第一次连接的日志①密码正确情况的日志②密码错误情况的日志③无密码情况的连接（2）保存状态连接的日志（3）断开连接的wi
  • 让你的写作保持节奏感 尼古拉我的猫
    如何让写作保持节奏感，就是写作是一项长期的事业，用百米冲刺的节奏去跑肯定不行，要有跑马拉松的精神状态去进行，将写作进行到底。很多小白刚进雄心壮志，恨不得一天更新好几篇文章，坚持不了一个月，就感觉灵感和素材都枯竭了，也就断了日更。还有更新文章的字数也有关系，文章保持在300到1000左右比较好，以这种状态匀速前进，既不会断更，又能保证文章的质量。小小的日更一百字，看似简单，能长期坚持下去，也非常的不
  • 玛雅日记13|最省力的活法，是找一个人来怪 Vidya程莹
    宇宙的红天行者kin13宇宙：当下持续/安忍超越灵性动物：乌龟问句：我如何散播自己的喜悦和爱？红天行者：觉醒空间探索行星狗之月第8天等离子Dali白色沉淀之周谦逊使静心升华左脚裸（宇宙）-左手无名指（红天行者）-顶轮（Dali）——13月亮历共时导航1.放下手中的抹布，我抱起泛着泪珠的球球，拍拍他的背，“对不起，宝贝，妈妈不该丢你的书包。”阴雨天，球球还是要去动物园玩，球爸爽快的答应了。穿什么衣服
  • 跨年和女朋友怎么过才有意义？跨年一般送女友什么东西？ 金钱保卫科长
    跨年，是一个充满浪漫与期待的时刻。当你和女朋友一起度过这个特殊的日子，你们将共同创造一份独特的回忆，让爱意在岁月的长河中流淌。为了让这个跨年之旅更加浪漫，我们为你提供一份特别的礼物建议，让你的女朋友感受到你的深深爱意。淘宝/京东/拼多多/唯品会/外卖等平台超级红包|活动无门槛红包https://www.chaojiyouhui京东跨年互动，红包、抽奖、促销商品优惠享不停！京东搜索：年年有余888一
  • Spring的单例模式 月亮太阳小星星 spring单例模式前端
    1.定义单例模式（SingletonPattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。Spring框架默认以单例模式创建Bean，这意味着在Spring容器中，每个Bean定义对应的实例在整个应用程序生命周期中只有一个。2.实现在Spring中，单例模式是通过@Scope注解和XML配置中的scope属性来实现的。默认情况下，SpringBean是单例的。2.1注
  • 家和万事兴 晚晴风竹
    每次回家，老妈总是满腹怨气的跟我抱怨说爸爸，抱怨姐姐抱怨儿子儿媳，总之没有一个让她满意的，没有一个让她觉得是省心的，每次看着她那张不开心的脸，我都有说不出的无奈。唉，都70多岁的人了，不知道她哪来的那么多怨气和戾气。那天又跟弟弟大发脾气，姐姐劝她不听又生姐姐的气，然后和自己赌气，最后一个人在房间里嚎啕大哭怨天尤人呼天抢地。姐姐打电话告诉我时，我真的不知道用什么语言来形容。妈妈只想别人对她如何，却从
  • 今日感悟 | 不同时段不同日更 知吾左左
    今天是左左日更的第185天（转自公众号左左心声）用语写记录心声在平凡中寻找力量最近做日更时，发现一个很有意思的现象，在一天不同时段完成日更，内容和状态完全不一样。早起第一时间进行日更，头脑很乱，似乎有很多话题可以分享，但哪个话题都深入不下去，更有压力。上午日更话题偏理性，一般都是总结最近的收获和感悟，形成方法，充实武器库。下午日更时，感性会比理性多一些，既会写感性话题，也会写理性话题。因为午休补充
  • 【Java设计模式】Caching模式：加速数据访问速度 道长不会写代码 java设计模式开发语言
    文章目录【Java设计模式】Caching模式：加速数据访问速度一、概述二、Caching设计模式的别名三、Caching设计模式的意图四、Caching模式的详细解释及实际示例五、Java中Caching模式的编程示例六、何时在Java中使用Caching模式七、Caching模式在Java中的实际应用八、Caching模式的优点和权衡九、源码下载【Java设计模式】Caching模式：加速数据
  • 商水公司总经理肖杰到马庄供电所参加供电服务投诉反思会 盖世荷包蛋
    2020年7月2日上午，商水公司总经理肖杰在副总经理赵海领的陪同下到马庄供电所参加供电服务投诉反思会，营销部主任张永旗及马庄供电所22名员工参加了此次反思会。公司副总经理赵海领主持会议。副总经理赵海领介绍了本次供电服务投诉反思会的目的。赵海领指出，通过召开此次会议，吸取经验教训，坚决做到年内同一时期、同一设备、同一人不能重复出现同一类投诉意见工单，一定要深刻进行分析反思，严肃处理每件投诉，让该受到
  • 面试难题：Redis分布式锁的原理和实现 Java爱好狂. redis分布式数据库spring面试
    对同一个资源进行操作，单一的缓存读取没问题了，但是存在并发的时候怎么办呢，为了避免数据不一致，我们需要在操作共享资源之前进行加锁操作。我们在开发很多业务场景会使用到锁，例如库存控制，抽奖，秒杀等。一般我们会使用内存锁的方式来保证线性的执行。但现在大多站点都会使用分布式部署，那多台服务器间的就必须使用同一个目标来判断锁。分布式与单机情况下最大的不同在于其不是多线程而是多进程。图1：分布式站点使用内存
  • 遗传算法：启发自真实现象 大龙10
    书名：代码本色：用编程模拟自然系统作者：DanielShiffman译者：周晗彬ISBN：978-7-115-36947-5第9章目录9.1遗传算法：启发自真实现象1、目标我们的目标不是深入研究遗传和进化的科学原理，我们不会研究旁氏表、核苷酸、蛋白质合成、RNA和其他生物进化相关的话题。相反，我们只讨论达尔文进化论背后的核心原理，并根据这个原理开发出一套算法。我们并不在乎进化模拟是否精确，只关心进
  • 日日精进 单家鞋城莲莲秋款陆续上市
    敬爱的单总，智慧的园姐，单家鞋铺的家人们大家好！我是来自高密单家鞋铺朱莲莲今天2018.8月17是我的327日，给大家分享我今天的进步，我们互相勉励1、比学习：晨会单总说了很多，自己也是成年人，为自己的事情负责任2比改变时刻改变自己，改变环境，改变氛围，3、比付出:客流很少，和宋姐华姐一起把组里恢复原样，继续把鞋子分类摆放，放地下清理库存，晚上凡凡自己在组里忙不开，进去一起帮忙，互相配合清理库存是
  • .Net中的泛型参数约束详解 _dejavu .Net日积跬步.netcore积累.net
    在.NET中，泛型参数约束用于确保泛型类型、方法或接口的类型参数满足特定的条件。这些约束有助于提高泛型代码的灵活性和类型安全性，允许编写更健壮和易于维护的应用程序。泛型参数约束带来的好处类型安全性：通过约束确保类型参数符合预期的类型特征，比如是引用类型或实现了特定接口，从而在编译时提供类型检查，避免运行时错误。性能提升：对于值类型（使用struct约束），泛型可以避免装箱和拆箱操作，这在处理大量数
  • 力扣11：链表相交 不会编程的屁屁桃 leetcode链表算法
    给你两个单链表的头节点headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null。如示例1所示，交点并不是1结点，而是8结点，相交结点是物理意义上的相交，也就是结点的地址相同，是同一个结点，而不是因为结点的值相等就是相交结点。classSolution{public:ListNode*getIntersectionNode(ListNode*headA,Li
  • 审慎VS积极——天赋才干使用说明书 林畅是个小太阳
    再看第5组的两个才干是审慎和积极，这两个才干也是对待事情持截然相反的观点，是保守谨慎、还是天然的乐观。我们一起来对比看下。1、审慎状态：谨慎保守、对风险敏感渴望：更多时间用于思考排雷贡献：把控风险、提出预期滤镜：要深思熟虑、不能拍脑袋阴影：犹豫纠结、错失机会协助：有利伙伴推动你决策审慎是执行力领域的才干。你的状态就是你能够预见到风险，对风险非常的敏感、谨慎、保守，能察觉出来事情有出问题的可能。你对
  • c++中类对象的构造和析构 TB81266 C++c++
    文章目录前言一、构造和析构函数二、构造函数的分类及调用三、构造函数调用规则研究前言创建一个对象时，常常需要作某些初始化的工作，例如对数据成员赋初值。注意，类的数据成员是不能在声明类时初始化的。为了解决这个问题，C++编译器提供了构造函数(constructor)来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。一、构造和析构函数构造
  • 分布式WebSocket-下篇 蓝天/zachary 分布式架构分布式websocket双向传输直播教育
    分布式WebSocket落地-生产验证上篇文章主要讲述了单点Socket，以及它的使用场景。本章主要会从多个维度来探讨单机Socket存在问题以及解决方案。上篇文章从功能层面实现了双向传输，但是带来了难受问题如下：我们把应用部署在一台2C4G服务器上运行，jvm参数如下：-Xmx2688M-Xms2688M-Xmn960M-XX:MaxMetaspaceSize=512M-XX:Metaspace
  • java+.Net版本 旗舰版企业版 JNPF 低代码-敏捷业务低代码开发平台 m0_73576999 java.net低代码开发语言前端
    低代码通常是指APaaS产品，通过为开发者提供可视化的应用开发环境，降低或去除应用开发对原生代码编写的需求量，进而实现便捷构建应用程序的一种解决方案。广义上低代码概念涵盖所有能够完成代码的集成，减少代码开发的应用过程和服务，但狭义上低代码的概念更倾向定位于满足企业业务端应用需求，通过可视化界面，利用少量代码或者无代码即可搭建简单应用和复杂企业级应用的独立开发平台。JNPF快速开发平台就是其中翘楚，
  • JNPF java版本3.4.1旗舰版 /微服务、单体 、JAVA 和.net6版本框架 「已注销」 java.net开发语言低代码微服务
    低代码通常是指aPaaS产品，通过为开发者提供可视化的应用开发环境，降低或去除应用开发对原生代码编写的需求量，进而实现便捷构建应用程序的一种解决方案。简单来说，低代码开发平台是一种软件开发工具，是可以通过无需编码或只用少量代码实现快速生成应用程序的开发平台。[DisassemblyDiagnoser(maxDepth:1)]//changeto0forjustthe[Benchmark]metho
  • 2018.7.2香格里拉泸沽湖 心园灵动
    2018.7.2随团行至云南香格里拉泸沽湖，见到了至白的云，至纯的景，至真的摩梭人和藏族人民，纯朴、热情好客的藏民邀至家中，感受不一样的藏传佛教文化，和当地的风土人情，和摩梭人仍保存至今的走婚民俗，是母系氏族的完美传承，是传说中的女儿国。图片发自App赏着藏民扎西的奔放的舞蹈和卓玛优美的歌声，图片发自App图片发自App图片发自App图片发自App图片发自App图片发自App图片发自App品尝着热
  • 【C++04】C++对象构造和析构 南风fahaxiki c++开发语言数据结构
    1、构造函数和析构函数构造函数和析构函数，这两个函数将会被编译器自动调用，完成对象初始化和对象清理工作。构造函数主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。析构函数主要用于对象销毁前系统自动调用，执行一些清理工作。1构造函数没有返回值不用写void函数名与类名相同可以有参数，可以发生重载构造函数由编译器自动调用一次无须手动调用2析构函数没有返回值不用写voi
  • 2019.2.13#复盘#day420 镇星Aquarius
    今年目标：健康管理（早睡11点之前、饮食、体重）白色LAVIDA找到一位合作伙伴今日青蛙：1.阅读。2.听音频。今日漫步：1.早起5:30打卡签到。2.阅读。3.听音频。4.社群维护。5.投资交易。6.做饭。7.复盘。多完成：做眼保健操未完成：没有不足：时间管理不好没有先做重要的事优点：早睡道理：人活着，不能没有追求，但万事不可强求，强求的人生，为难了别人，也拧巴了自己。有些事，尽管我们费尽心力，
  • 我喜欢的一本书 森林根
    目前，我最喜欢的书是《人性的弱点》，它的标签是风靡全球的励志经典著作，改变了千万人命运的智慧之书，被誉为“人类出版史上的奇迹”，这一点我无从考证，但是它确实改变了我在生活中的一些行为和语言。很多人都抱怨生活不易，在生活中并不是一帆风顺，特别是与人交往时，往往觉得困难。不知道该如何了解别人，如何与人相处，如何使人喜欢，如何使他人同意你的想法等等。如果你也有如上这些问题，《人性的弱点》这本书里就有你需
  • 第六章笔记 笛翊
    “弃之如敝履”要建造高瞻远瞩公司，不需要创造一个“温和”或“舒适”的环境，就绩效和契合公司理念而言。高瞻远瞩公司对员工的要求远比其他公司要严。之前作者所提到的罗伯特在发现自己不能对诺思通公司的业务保持高度热情之后就离开了。与对照公司相比，高瞻远瞩公司有以下几个特点：热烈拥护的理念，灌输信仰，严密契合，精英主义。举例IBM:IBM获得最大成就，展现最能适应世界变化的杰出能力时，正是其教派般的文化表现
  • SEO之搜索引擎的工作原理（一） luckyboy0077 搜索引擎经验分享
    初创企业需要建站的朋友看这篇文章，谢谢支持：我给不会敲代码又想搭建网站的人建议搜索引擎工作过程非常复杂，接下来的几节我们简单介绍搜索引擎是怎样实现网页排名的。下面介绍的内容相对于真正的搜索引擎技术来说只是皮毛，不过对SEO人员已经足够用了。搜索引擎的工作过程大体上可以分成三个阶段：(1)爬行和抓取：搜索引擎蜘蛛通过跟踪链接访问网页，获得页面HTML代码存入数据库。(2)预处理：索引程序对抓取来的页
  • 数据采集高并发的架构应用 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其他