安科网

【Dubbo】Zookeeper+Dubbo项目demo搭建

Fightingxr

Fightingxr

2019-10-25

关注 关注

一、Dubbo的注解配置

在Dubbo 2.6.3及以上版本提供支持。

1、@Service（全路径@org.apache.dubbo.config.annotation.Service）

配置服务提供方用以暴露服务，添加于api接口的实现类上，并可通过注解提供的属性进一步定制化服务。

其中比较重要的属性有：

  1. @Service只能定义在一个类上，用以提供一个服务的具体实现
  2. interfaceClass：指定服务提供方实现的interface的类
  3. interfaceName：指定服务提供方实现的interface的类名
  4. version
  5. group：指定服务分组
  6. export：是否暴露服务
  7. register：是否向注册中心注册服务
  8. application：应用配置
  9. module：模块配置
  10. provider：服务提供方配置
  11. protocol：传输层协议配置
  12. monitor：监控中心配置
  13. registry：注册中心配置

注意，8-13需要提供对应的spring bean的名字，bean的组装可以通过传统的XML配置方式完成，或者Java Config的方式配置（推荐使用）。

2、@Reference（全路径@org.apache.dubbo,config.annotation.Reference）

服务消费方用以引用服务，通过动态代理来实现接口的引用，同样可通过注解提供的属性进一步定制化服务。

其中比较重要的属性有：

  1. @Reference通常定义在一个字段上，表示一个服务的引用
  2. interfaceClass：指定服务的interface的类
  3. interfaceName：指定服务的interface的类名
  4. version
  5. group
  6. url：指定服务提供方的URL地址，绕过注册中心直接发起调用
  7. application：应用配置
  8. module：模块配置
  9. consumer：服务消费方配置
  10. protocol：协议配置
  11. monitor：监控中心配置
  12. registry：注册中心配置

同上，7-12需要提供对应的spring bean的名字，推荐使用Java Config的方式进行组装Bean。

3、@EnableDubbo（全路径org.apache.dubbo.config.spring.context.annotation.EnableDubbo）

@EnableDubbo注解是@EnableDubboConfig和@DubboComponentScan两者组合的便捷表达。

@EnableDubbo提供scanBasePackages和scanBasePackageClasses属性，可以在指定的包名或者类中扫描Dubbo的服务提供者（@Service标注）和服务消费者（@Reference标注），扫描到服务的提供者或消费者后，对其进行相应的组装并初始化， 最终完成服务的暴露或引用。

扫描提供者和消费者的功能@DubboComponnetScan也可以实现，@EnableDubboConfig提供外部化配置的支持。

二、Dubbo的API属性配置

目前，通过@Service、@Reference、@EnableDubbo注解，实现了服务的暴露和发现引用，除此之外，还需要一些其他的属性配置，诸如应用名、注册中心、协议信息等。

1、Dubbo中配置类结构

 【Dubbo】Zookeeper+Dubbo项目demo搭建

2、注入这些配置属性，有两种方式，分别是采用配置文件和Java Config硬编码的形式。

2.1、配置文件方式

在resources下创建xxx.properties文件，在其中添加各项属性配置，形式如下：

dubbo.application.name=provider
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

然后通过@PropertySource("classpath:/xxx.properties")注解导入配置；

导入属性在启动时，会被自动组装成相应的配置类。

2.2、Java Config硬编码方式

创建providerConfiguration类，标注@Configuration注解；

在该类中，通过@Beab的形式分别配置需要的配置类，如下：

@Bean
public ApplicationConfig applicationConfig() {
　　ApplicationConfig applicationConfig = new ApplicationConfig();
　　applicationConfig.setName("provider");
　　return applicationConfig;
}

@Bean
public ProtocolConfig protocolConfig() {
　　ProtocolConfig protocolConfig = new ProtocolConfig();
　　protocolConfig.setName("dubbo");
　　protocolConfig.setPort("20880");
　　return protocolConfig;
}

@Bean
public RegistryConfig registryConfig() {
　　RegistryConfig registryConfig = new RegistryConfig();
　　registryConfig.setProtocol("zookeeper");
　　registryConfig.setAddress("localhost");
　　registryConfig.setPort(2181);
　　return registryConfig;
}

在具体实现中，创建Config类，通过Java Config技术（@Configuration）和annotation扫描（@EnableDubbo）来发现、组装服务提供者和消费者。

三、其他相关Spring注解

1、@Configuration（全路径org.springframework.context.annotation.Configuration）

@Configuration注解用来定义配置类，可替换XML配置文件，被注解类内有多个@Bean标注方法，这些方法会被AnnotationConfigApplicationContext或者AnnotationConfigWebApplicationContext类进行扫描，用于构建bean并初始化spring容器。

@Configuration注解的配置类有以下要求：

    • @Configuration注解的配置类不可以是final类型。
    • 内部嵌套的内部Configuration类必须是静态类。

1.1、@Configuration配置spring并启动spring容器

起到为spring容器配置应用上下文的作用：

ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);

效果等价于用XML文件配置：

ApplicationContext context = new ClassPathXmlApplicationContext("test-spring-context.xml");

1.2、@Configuration启动容器注册bean，@Bean下管理bean的生命周期

@Bean标注在方法上，作用相当于注册Bean，注意：

    • @Bean标注在返回实例的方法上，如果未通过@Bean指定bean的名称，默认与标注方法名同名。
    • @Bean标注默认bean作用域为单例singleton，可通过@Scope()设置。
    • @Bean的作用是注册bean，因此也可以用@Component、@Controller、@Service、@Repository等进行注册，不过需要配置@ComponentScan注解进行自动扫描。
    • 可以通过@Bean管理bean的生命周期。

1.3、组合多个配置来源

通过@ImportSource("classpath:/xxx.xml")导入XML配置文件；

通过@Import(TestConfiguration.class)导入其他配置类；

通过@Configuration嵌套（嵌套额Configuration类必须为静态类）。

2、@Component、@Service、@Controller、@Repository、@RestController、@Bean

修饰的类均会被扫描到并注入到spring的bean容器中。

2.1、@Component

通用注解，可以被注入到spring容器进行管理。

2.2、@Service、@Controller、@Repository是针对不同使用场景采用的特定功能化的注解组件。

    • @Service：作用于业务逻辑层
    • @Controller：作用于表现层（springMVC注解），注解的bean会被spring-mvc框架使用，进行前端请求的处理、转发、重定向，包括调用service层的方法
    • @Repository：作用于持久层，表明该类是用来执行与数据库相关的操作，并支持自动处理数据库操作产生的异常

2.3、@Controller和@RestController

首先两者都是表明该类可以接受HTTP请求，@RestController相当于@的作用。

在@RestController中，返回的应该是一个对象，即使没有前端界面的渲染，也可以看到返回的是该对象对应的json字符串，而前端的作用就是利用返回的json进行解析并渲染界面。

在@Controller中，返回的是一个字符串，或者代表与字符串匹配的模板名称，与HTML页面配合使用。

    1. 如果只是用@RestController注解，则Controller方法中无法返回jsp页面，配置的视图解析器InternalResourceViewResolver不起作用，返回的内容就是方法中return的值。
    2. 如需要指定返回某个页面，则需要用@Controller配合视图解析器InternalResourceViewResolver使用。
    3. 如果需要返回Json、XML或自定义的mediaType内容到页面，@RestController直接就能做到，但在@Controller中需要在相应方法上加上@ResponseBody注解。

2.4、@Bean和@Component（@Service、@Controller、@Repository）的区别

  • @Component注解表明一个类作为组件类，并告知spring为该类创建bean。
  • @Bean注解告诉spring这个方法将返回一个对象，该对象要注册为spring应用上下文中的bean。

两者目的都是注册bean到Spring容器中。

  • @Component通常是通过类路径扫描来自动侦测并自动装配到spring容器中。作用于类。
  • @Bean注解通常是我们在标有该注解的方法中自定义产生这个bean的逻辑。作用于方法。

3、@Autowired、@Resource

@Autowired默认按照类型装配。

默认要求依赖的对象必须存在，若允许为NULL，可以设置required属性为false。

@Resouce默认按照名称装配。

可以通过name属性指定，指定了name属性，就只能按照名称装配。

有两个重要的属性，name和人type，将name属性解析为bean的名字，type解析为bean的类型。

使用了name属性，则使用byName的自动注入策略；而使用type属性，则使用byType的自动注入策略。

@Resouce的装配顺序：

  1. 同时指定了name和type属性，从spring上下文找到唯一匹配的bean进行装配，找不到则抛出异常。
  2. 指定了name属性，从上下文查找名称匹配的bean进行装配，找不到则抛出异常。
  3. 指定了type属性，从上下文查找类型匹配的唯一bean进行装配，找不到或者找到多个则抛出异常。
  4. 属性均未指定，则默认按照byName的方式进行查找装配。

4、@PropertySource、@ImportResource

@ImportResource：导入spring的配置文件，如xxx.XML。

@PropertySource

@ConfigurationProperties是默认从全局配置文件中获取指定的值，例如@ConfigurationProperties(prefix=“person”)是从application.yml(properties)中加载person的属性并映射到对应类的属性。

如果配置在xxx.properties中（非全局配置文件），就需要用@PropertySource(value={"classpath:/xxx.properties"})导入指定配置文件。

四、项目搭建流程

1、注册中心Zookeeper搭建

Zookeeper的安装不在此介绍，可参考：Zookeeper单点与集群安装

2、项目框架搭建

创建maven项目hello_dubbo，删掉其中的src文件夹，并添加对spring-boot的依赖，作为整个项目运行环境。

新建new module，依次为api（服务接口公共包）、provider（服务提供者模块）、consumer（服务消费者模块）,。

此时项目结构如图：

【Dubbo】Zookeeper+Dubbo项目demo搭建

pom文件关键信息为：

<groupId>com.li</groupId>
<artifactId>hello_dubbo</artifactId>
<version>1.0-SNAPSHOT</version>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.9.RELEASE</version>
    <relativePath/>
</parent>

<modules>
    <module>api</module>
    <module>provider</module>
    <module>consumer</module>
</modules>

hello_dubbo_pom.xml

3、api包

在pom文件中配置依赖关系：

<parent>
    <groupId>com.li</groupId>
    <artifactId>hello_dubbo</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

<artifactId>api</artifactId>

api_pom.xml

在api包中创建要对外提供服务的接口类HelloAPI.java：

package com.li.api;

public interface HelloApi {

    public String sayHello(String name);
}

HelloApi

此时的api模块结构：

【Dubbo】Zookeeper+Dubbo项目demo搭建

4、provider项目

1、修改pom文件，添加相关依赖：

<parent>
    <groupId>com.li</groupId>
    <artifactId>hello_dubbo</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

<artifactId>provider</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>provider</name>

<dependencies>
    <!--web支持-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--添加Zookeeper依赖-->
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.5.5</version>
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!--添加Dubbo依赖，已并入apache-->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.7.3</version>
    </dependency>
    <!--添加zookeeper客户端框架Curator-->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--添加对API模块的依赖-->
    <dependency>
        <groupId>com.li</groupId>
        <artifactId>api</artifactId>
        <version>1.0-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

provider_pom.xml

2、添加service包，在其中创建api接口的实现类，提供服务的具体实现，并用@Service暴露服务：

package com.li.provider.service;

import com.li.api.HelloApi;
import org.apache.dubbo.config.annotation.Service;

@Service
public class HelloService implements HelloApi {

    @Override
    public String sayHello(String name) {
        return "hello " + name;
    }
}

HelloService

3、provider的配置注入方式选择采用properties文件的形式。

在resources下添加provider.properties配置文件：

dubbo.application.name=helloP
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
server.port=8001

provider.properties

在主目录下创建Configuration类，作为配置类：

package com.li.provider;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@EnableDubbo(scanBasePackages = "com.li.provider.service")
@PropertySource("classpath:/provider.properties")
public class ProviderConfiguration {
}

ProviderConfiguration

4、启动类选择springBoot启动：

package com.li.provider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }

}

ProviderApplication

5、至此，Provider模块完成，项目结构如下：

【Dubbo】Zookeeper+Dubbo项目demo搭建

5、consumer项目

1、修改pom文件，添加相关依赖：

<parent>
    <groupId>com.li</groupId>
    <artifactId>hello_dubbo</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

<artifactId>consumer</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>consumer</name>

<dependencies>
    <!--web支持-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--添加Zookeeper依赖-->
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.5.5</version>
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!--添加Dubbo依赖，已并入apache-->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.7.3</version>
    </dependency>
    <!--添加zookeeper客户端框架Curator-->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--添加对API模块的依赖-->
    <dependency>
        <groupId>com.li</groupId>
        <artifactId>api</artifactId>
        <version>1.0-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

consumer_pom.xml

2、创建action包，新增HelloAction类，作为MVC框架的service层，提供业务逻辑处理并利用@Reference提供对远程服务的引用：

package com.li.consumer.action;

import com.li.api.HelloApi;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

@Service    //注意为spring的@Service注解，将其作为bean管理
public class HelloAction {

    @Reference(check = false)
    private HelloApi helloApi;

    public String doHello(String name) {
        return helloApi.sayHello(name);
    }
}

HelloAction

3、创建controller包，新增HelloController类，作为MVC框架的controller层，提供前端请求的转发，以及业务逻辑的调用：

package com.li.consumer.controller;

import com.li.consumer.action.HelloAction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private HelloAction action;

    @GetMapping("/hello")
    public String hello(@RequestParam("name")String name) {
        return action.doHello(name);
    }
}

HelloController

4、consumer的配置注入方式选择采用Java Config硬编码的形式。

在resources下添加consumer.properties配置文件：

1 server.port=8002    //注册对外提供服务的端口

consumer.properties

在主目录下创建Configuration类，作为配置类：

package com.li.consumer;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:/consumer.properties")
public class ConsumerConfiguration {

    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig config = new ApplicationConfig();
        config.setName("helloC");
        return config;
    }

    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig config = new RegistryConfig();
        config.setAddress("zookeeper://127.0.0.1:2181");
        return config;
    }
}

ConsumerConfiguration

5、启动类选择springBoot启动：

package com.li.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

}

ConsumerApplication

6、至此，Consumer模块完成，项目结构如下：

【Dubbo】Zookeeper+Dubbo项目demo搭建

6、项目启动

项目启动时，首先启动Zookeeper，命令行执行zkServer.cmd。

正常启动顺序应该先启动提供者，然后启动消费者，因为@Reference注解在启动时默认会去注册中心检查所引用服务状态是否正常提供服务，若想先启动消费者，可选择关闭检查功能，@Reference(check=false)。

全部启动后，可打开zk客户端查看已注册服务情况。

【Dubbo】Zookeeper+Dubbo项目demo搭建

最后打开浏览器，访问localhost:8002/hello?name=world发现正常引用服务。

【Dubbo】Zookeeper+Dubbo项目demo搭建

dubbo config

Fightingxr

Fightingxr

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

Dubbo中的时间轮(Time Wheel)算法应用

Netty、Quartz、Kafka 以及 Linux 都有定时任务功能。在任务量大、性能要求高的场景，为了将任务存取及取消操作时间复杂度降为 O，会采用时间轮算法。指针周期性跳动，跳动到一个槽位，就执行该槽位的定时任务。需要高效的定时器算法以减少总体中断

ATenhong 2020-10-15

女朋友问我：Dubbo的服务引用过程

本文转载自微信公众号「三太子敖丙」，作者三太子敖丙 。这篇文章我就带着大家再来看看 Dubbo 服务引入全流程，这篇服务引入写完下一篇就要来个全链路打通了，看看大家看完会不会有种任督二脉都被打通的感觉。在写文章的过程中丙还发现官网的一点小问题，下文中会提

supperme 2020-09-08

Java 200+ 面试题补充③ Dubbo 模块

今天 Java 面试粉丝群里，一个一年开发经验的小伙伴只用了三天时间，找了一个 13 薪 1.5 万的工作，真是替他感到开心。高兴之余，让我们来看，今天的内容。本文是 Java 最常见的 200+ 面试题 的第三个补充模块。Dubbo 是一款高性能、轻量级

doctorvian 2020-08-02

上线前一个小时，dubbo这个问题可把我折腾惨了

前因那是一个月黑风高的夜晚，不管有没有圆圆的月亮，都无法解救要加班的我。这就是苦涩的人生啊！那天正好是春节回家的日子，定了晚上的票，然后还是上线的日子。测试在做回归测试的时候，发现一个老功能报错了，什么鬼，都没改过那块代码怎么会出问题？案件疑点重重呀。。。

aNian 2020-08-01

Dubbo不用注册中心实现远程调用的简单用法demo

return "Hello ,liaoyang make you see " + msg;

gaoyongstone 2020-07-05

微服务架构框架？这里为你汇总了15种

2019年有一个统计说，两千家企业里，45%在使用微服务，16%在实验开发和测试微服务架构，24%在学习微服务准备转型，只有剩下的15%的企业没有使用微服务。对于中大型架构系统来说，微服务更加便捷，微服务成为很多企业架构重构的方向，同时也对架构师提出更高的

kongjunlongaa 2020-06-29

Dubbo telnet 命令能做什么？

dubbo 服务发布之后，我们可以利用 telnet 命令进行调试、管理。telnet localhost 20880 //键入回车进入 Dubbo 命令模式。ls -l XxxService：显示服务的方法详细信息列表。

Fightingxr 2020-06-26

spring cloud 知识点

spring cloud 是一系列框架的有序集合。它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和

whileinsist 2020-06-24

Dubbo-扩展机制-SPI

从上面可以看出Java中的SPI最大的缺点是会加载一些不必要的组件。ExtensionLoader类是扩展加载器，这是dubbo实现SPI扩展机制等核心，几乎所有实现的逻辑都被封装在ExtensionLoader中

doctorvian 2020-06-16

Dubbo-URL、数据包结构

在 dubbo 中，也使用了类似的 URL，主要用于在各个扩展点之间传递数据，组成此 URL 对象的具体参数如下:. 基于扩展点自适应机制，通过 URL 的 registry:// 协议头识别，就会调用 RegistryProtocol 的 export(

XuNeely 2020-06-16

Dubbo-服务提供者初始化

事件发布，执行onApplicationEvent，开始执行ServiceBean暴露export操作。当Spring容器处理完<dubbo:service>标签后，会在Spring容器中生成一个ServiceBean ，服务的发布也会在Ser

wangyangsoftware 2020-06-16

Dubbo-服务暴露流程

zk节点上生成providers节点的过程。// FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and ca

大步流星 2020-06-16

Dubbo-服务消费者远程调用

* 这里输入编号 3，让 Arthas 关联到启动类为 com.....Consumer 的 Java 进程上。* 3. 由于 Demo 项目中只有一个服务接口，因此此接口的代理类类名为 proxy0，此时使用 sc 命令搜索这个类名。public cla

aNian 2020-06-16

涂鸦智能 dubbo-go 亿级流量的实践与探索

潘天颖，Github ID @pantianying，开源爱好者，就职于涂鸦智能。dubbo 是一个基于 Java 开发的高性能的轻量级 RPC 框架，dubbo 提供了丰富的服务治理功能和优秀的扩展能力。而 dubbo-go 在 java 与 golan

gaoyongstone 2020-06-16

9.实战交付一套dubbo微服务到k8s集群(2)之Jenkins部署

[200 ~]# ssh-keygen -t rsa -b 2048 -C "" -N "" -f /root/.ssh/id_rsa

MartellJenkins 2020-06-11

Dubbo学习

前言为什么要学Dubbo什么是RPCDubbo的产生背景单一应用架构垂直应用架构分布式服务架构流动计算架构Dubbo面临的需求Dubbo的架构Demo time新建一个maven项目提供服务的API提供服务的provider消费服务的consumer参考。

范群松 2020-06-11

Dubbo 迈出云原生重要一步 - 应用级服务发现解析

社区版本 Dubbo 从 2.7.5 版本开始，新引入了一种基于实例（应用）粒度的服务发现机制，这是我们为 Dubbo 适配云原生基础设施的一步重要探索。在最开始的社区版本，我们给这个机制取了一个神秘的名字 - 服务自省，下文将进一步解释这个名字的由来，并

Fightingxr 2020-06-08

线程隔离浅析

随着微服务的流行，单体应用被拆分成一个个独立的微进程，可能一个简单的请求，需要多个微服务共同处理，这样其实是增加了出错的概率，所以如何保证在单个微服务出现问题的时候，对整个系统的负面影响降到最低，这就需要用到我们今天要介绍的线程隔离。connection在

XuNeely 2020-06-07

SPI

SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。D

大步流星 2020-06-05

[dubbo学习] 简单的dubbo功能

生产者-消费者模型，生产者和消费者都需要在注册中心进行注册，生产者生产接口，通过api暴露给消费者使用。服务消费者在启动时，在注册中心订阅自己所需的服务。注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。服务消费

gaoyongstone 2020-06-05
Fightingxr

Fightingxr

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号