Analisis kod sumber Dubbo: Panduan pemula

Jika anda sudah mempunyai kiri: 2px; warna latar: rgba(27, 31, 35, 0.05); ; word-break: break-all; color: rgb(239, 112, 96);">DubboDubbo熟练使用了，那这篇文章不太适合你，但如果想了解Dubbo，想学习Dubbo，那就非常适合你。

什么是Dubbo？

Dubbo一开始是由阿里巴巴开发，后面贡献给了Apache，所以后面我们称之为Apache Dubbo或者直接叫Dubbo。

DubboJika anda mahir menggunakannya, maka artikel ini tidak sesuai untuk anda, tetapi jika anda mahu tahu lebih lanjut

Dubbo

, nak belajar

Apache, jadi kami akan memanggilnya Apache Dubboatau panggil saja Dubbo. 🎜🎜Dubbo ialah prestasi tinggi, Rangka kerja perkhidmatan sumber terbuka yang ringan. 🎜🎜🎜Betulkan sebutan dahulu: 🎜

Sebutan yang salah: diubo, dubo

Sebutan yang betul: |ˈdʌbəʊ|

Enam keupayaan teras Dubbo

• Prestasi tinggi untuk ejen antara mukaRPC call
RPC调用

智能容错和负载均衡

服务自动注册和发现

高度可扩展能力

运行期流量调度

可视化的服务治理与运维。

开发中，我们都喜欢把Dubbo简称为RPC开源框架。

什么是RPC？

RPC是Remote Procedure Call的简称，翻译过来就是：远程过程调用

Toleransi kesalahan pintar dan imbangan beban li>

Pendaftaran automatik dan penemuan perkhidmatan

Keupayaan berskala tinggi

Penjadualan trafik masa jalan🎜🎜Perkhidmatan tervisualisasi Tadbir urus dan operasi. 🎜Semasa pembangunan, kita semua suka menggunakan Dubbo dirujuk sebagai RPCRangka kerja sumber terbuka. 🎜

Apakah itu RPC?

🎜RPC ialah Panggilan Prosedur Jauhsingkatan, diterjemahkan sebagai: Panggilan prosedur jauh. 🎜🎜🎜Pemahaman mudah ialah satu nod meminta perkhidmatan yang disediakan oleh nod lain. 🎜🎜🎜Dalam istilah orang awam:🎜

Dua pelayan A dan B menggunakan aplikasi serverA，在服务器B上部署一个应用程序serverB。此时，serverA想调用serverB pada pelayan A. Kaedah tertentu tidak boleh dipanggil terus kerana ia tidak berada dalam pelayan yang sama Semantik panggilan dan data panggilan perlu dihantar melalui rangkaian.

Panggil kaedah jauh seperti memanggil kaedah tempatan.

Dalam pembangunan kami, panggilan antara dua perkhidmatan (perkhidmatan pada pelayan berbeza) biasanya menggunakan HTTP REST.

Rangka kerja RPC

Malah, terdapat banyak rangka kerja RPC di pasaran, dan Dubbo hanyalah salah satu daripadanya. Contohnya:

• gRPC ialah rangka kerja RPC sumber terbuka universal yang berprestasi tinggi yang dibangunkan oleh Google gRPC menggunakan ProtoBuf untuk mentakrifkan perkhidmatan ProtoBuf ialah protokol siri data yang dibangunkan oleh Google. Ia mempunyai prestasi yang agak tinggi, pemampatan tinggi dan kecekapan penghantaran sintaks yang mudah. Di samping itu, gRPC menyokong pelbagai bahasa dan secara automatik boleh menjana perpustakaan fungsi klien dan pelayan berdasarkan bahasa.
• Thrift berasal dari Facebook dan, seperti Dubbo, kemudiannya diserahkan kepada Yayasan Apache untuk menjadikan Thrift projek sumber terbuka. Facebook mencipta Thrift untuk menyelesaikan masalah penghantaran data dan komunikasi yang banyak antara sistem Facebook, serta persekitaran bahasa yang berbeza antara sistem yang memerlukan isu merentas platform.
• Motan ialah rangka kerja Java RPC sumber terbuka oleh Sina Weibo Menurut dokumen rasmi, ia telah digunakan secara meluas pada platform Weibo, menyelesaikan hampir 100 bilion panggilan untuk ratusan perkhidmatan setiap hari. . 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">Peranan teras dalam Dubbo seni bina:

  

• Gambar ini datang dari laman web rasmi. Jom berikan pengenalan ringkas tentang gambar di bawah:
  data -tool="mdnice editor" style="margin-top: 30px;margin-bottom: 15px;font-weight: bold;font-size: 18px;">Registry
  Pusat pendaftaran. Bertanggungjawab untuk pendaftaran dan carian alamat perkhidmatan, perkhidmatan Pembekal dan <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05 );font-family: " operator mono consolas monaco menlo monospace break-all rgb>Pengguna hanya berfungsi dengan Pendaftaran interaksi pusat. Pusat pendaftaran merasakan sambungan panjangKewujudan Pembekal , dalam Pembekal Apabila terdapat masa henti, Pusat pendaftaran akan segera menolak pemberitahuan acara yang berkaitanPengguna .

Pembekal

Pembekal perkhidmatan. Apabila ia bermula, ia akan mendaftar dengan Pejabat Pendaftaran, merangkum alamat perkhidmatannya sendiri dan maklumat konfigurasi yang berkaitan ke dalam URL dan menambahkannya ke ZooKeeper.

Pengguna

Melayani pengguna. Apabila ia bermula, ia akan melanggan Pendaftaran. Operasi langganan mewujudkan sambungan daripada ZooKeeper 中获取 Provider 注册的 URL，并在 ZooKeeper 中添加相应的监听器。获取到 Provider URL 之后，Consumer 会根据负载均衡算法从多个 Provider 中选择一个 Provider 并与其建立连接，最后发起对 Provider 的 RPC 调用。如果 Provider URL 发生变更，Consumer 将会通过之前订阅过程中在注册中心添加的监听器，获取到最新的 Provider URL 信息，进行相应的调整，比如断开与宕机 Provider 的连接，并与新的 Provider.Fungsi Pengguna dan Provider 建立的是长连接，且 Consumer 会缓存 Provider 信息，所以一旦连接建立，即使注册中心宕机，也不会影响已运行的 Provider 和 Consumer。

Monitor

监控中心。用于统计服务的调用次数和调用时间。Provider 和 Consumer 在运行过程中，会在内存中统计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。监控中心在上面的架构图中并不是必要角色，监控中心宕机不会影响 Provider、Consumer 以及 Registry hanya akan kehilangan data pemantauan.

Ia berkembang secara tidak senonoh dan meletup pada peringkat kemudian (anda mungkin tidak memberi banyak perhatian kepadanya pada peringkat awal, tetapi ia sangat wangi pada peringkat kemudian)

Bekas:

Bekas berjalan servis. ialah bekas yang berasingan kerana perkhidmatan biasanya tidak memerlukannya (27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb (239, 112, 96);">Tomcat、JBoss dan bekas web lain mempunyai ciri, tidak perlu menggunakan bekas web untuk memuatkan perkhidmatan. Bekas perkhidmatan hanyalah kaedah utama yang mudah dan memuatkan bekas Spring mudah untuk mendedahkan perkhidmatan. Tomcat、JBoss等Web容器的特性，没必要用Web容器去加载服务。服务容器只是一个简单的main方法，并加载一个简单的Spring容器，用于暴露服务。

流程说明

在上面这张图中，有几个角色，并且还画了很多线条，下面我们对此做一个简单说明。

• 服务容器负责启动，加载，运行服务提供者。
• 服务提供者在启动时，向注册中心注册自己提供的服务。
• 服务消费者在启动时，向注册中心订阅自己所需的服务。
• 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
• 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
• 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

Dubbo官网

Dubbo的官网：https://dubbo.apache.org/



由于Dubbo

Penerangan proses

Di atas Dalam ini gambar, terdapat beberapa watak dan banyak garisan yang dilukis Mari kita berikan penjelasan ringkas di bawah. 🎜
• Bekas perkhidmatan bertanggungjawab untuk memulakan, memuatkan dan menjalankan pembekal perkhidmatan.
• Pembekal perkhidmatan Di permulaan, daftarkan perkhidmatan yang anda sediakan dengan pusat pendaftaran.
• Perkhidmatan pengguna Di permulaan, langgan pusat pendaftaran untuk perkhidmatan yang anda perlukan.
• Pulangan Pusat Pendaftaran Senarai alamat pembekal perkhidmatan diberikan kepada pengguna Jika terdapat perubahan, pusat pendaftaran akan menolak data perubahan kepada pengguna berdasarkan sambungan yang panjang.
• Pengguna perkhidmatan , daripada senarai alamat pembekal, berdasarkan algoritma pengimbangan beban lembut, pilih pembekal untuk dihubungi Jika panggilan gagal, pilih pembekal lain untuk dihubungi.
• Pengguna perkhidmatan dan pembekal, kumpulkan bilangan panggilan dan masa panggilan dalam ingatan, dan kerap menghantar data statistik ke pusat pemantauan setiap minit.

laman web rasmi Dubbo

🎜Tapak web rasmi Dubbo: https://dubbo.apache.org/🎜

🎜

🎜DisebabkanDubbodibangunkan oleh pasukan teknikal Alibaba, jadi dokumentasi adalah sangat penting kepada kami di China Dari perspektif manusia, ia agak mesra Dalam satu perkataan: sejuk! 🎜

Selain itu, Dubbomempunyai banyak perkara pada laman web rasminya Kami tidak akan memperkenalkan mereka satu persatu di sini. Dubbo官网上很多东西，我们就不在这里一一介绍了。

建议大家都去官网逛逛。

话不多说，咱们先来嗨一把！

demo案例1

我们先来搞一个没有注册中心的案例。

我们搭建一个项目，并创建三个module：

• dubbo-demo
• dubbo-demo-api
• dubbo-demo-provider
• dubbo-demo-consumer

  Adalah disyorkan agar semua orang pergi ke tapak web rasmi.

Tanpa berlengah lagi, mari berseronok dahulu!

kas demo 1

Mari kita mulakan dengan kes tanpa pusat pendaftaran.

Kami membina projek dan mencipta tiga modul：<p style="text-align: center;padding: 0px 0.5em;"></p> <ul class="list-paddingleft-2" data-tool="mdnice editor" style="margin-top: 8px;margin-bottom: 8px;padding-left: 25px;"><li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);"><code style="font-size: 14px;padding: 2px 4px; jidar-jejari: 4px;margin-kanan: 2px;margin-kiri: 2px;warna latar belakang: rgba(27, 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace word-break: break-all rgb>dubbo-demo

dubbo-demo-api

dubbo-demo- provider kod>🎜<li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);"><code style="font- saiz: 14px;padding: 2px 4px;border-radius: 4px;margin-kanan: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb>dubbo-demo-consumer🎜🎜🎜🎜Struktur keseluruhan projek ialah seperti berikut :🎜🎜🎜🎜🎜🎜🎜Sekarang, mari berikan penjelasan ringkas tentang kod tersebut. 🎜

Pertama ialah pomDependencies: pom依赖：

<!--dubbo的依赖-->
<dependency>
     <groupId>org.apache.dubbo</groupId>
     <artifactId>dubbo</artifactId>
     <version>3.0.4</version>
</dependency>
<!-- provider和consumer共用类-->
<dependency>
     <groupId>com.tian.dubbo</groupId>
     <artifactId>dubbo-demo-api</artifactId>
     <version>1.0-SNAPSHOT</version>
</dependency>

consumer和provider项目都需要添加这两个依赖。

api

api主要是定义服务接口以及一些工具类，主要是供consumer和provider共用。

在api中我们只定义了一个服务接口：DemoService

package com.tian.dubbo.service;

public interface DemoService {
    String sayHello(String msg);
}

然后打成jar，在consumer和provider项目中添加到pom.xml依赖里，最后两遍都可以使用了。

provider

在resources目录下创建一个目录META-INF.spring，然后在目录下创建一个application.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!--Dubbo服务名称--> 
    <dubbo:application name="dubbo-provider"/>
    <!--不需要注册到服务注册中心--> 
    <dubbo:registry address="N/A"/>
    <!--端口和协议--> 
    <dubbo:protocol name="dubbo" port="20880"/>
    <!--我们的服务--> 
    <dubbo:service interface="com.tian.dubbo.service.DemoService" ref="demoService"/>
    <bean id="demoService" class="com.tian.dubbo.service.DemoServiceImpl"/>
</beans>

再在resources目录下创建一个日志打印的配置文件：log4j.properties

###set log levels###
log4j.rootLogger=debug, stdout
###output to the console###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%d{dd/MM/yy HH:mm:ss:SSS z}] %t %5p %c{2}: %m%n

在定义一个业务实现类：DemoServiceImpl

package com.tian.dubbo.service;

public class DemoServiceImpl implements DemoService {
    public String sayHello(String msg) {
        System.out.println("msg= " + msg);
        return "SUCCESS";
    }
}

再就是定义一个provider的启动类：ProviderMain

package com.tian.dubbo;

import org.apache.dubbo.container.Main;

public class ProviderMain {
    public static void main(String[] args) {
        Main.main(args);
    }
}

< blockquote data-tool="mdnice editor" style="border-top: none;border-right: none;border-bottom: none;font-size: 0.9em;overflow: auto;color: rgb(106, 115, 125 );padding: 10px 10px 10px 20px;margin-bottom: 20px;margin-top: 20px;border-left-color: rgb(239, 112, 96);background: rgb(255, 249, 249);"> < p style="font-size: 16px;padding-top: 8px;padding-bottom: 8px;color: black;line-height: 26px;">Kedua-dua projek pengguna dan pembekal perlu menambah dua kebergantungan ini.

api

🎜 API terutamanya mentakrifkan antara muka perkhidmatan dan beberapa kelas alat, yang kebanyakannya dikongsi oleh pengguna dan pembekal. 🎜🎜Dalam api kami hanya mentakrifkan satu antara muka perkhidmatan: DemoService 🎜

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 服务名称-->
    <dubbo:application name="dubbo-consumer"/>
    <!--不需要注册到服务注册中心--> 
    <!-- 通过url直接调用-->
    <dubbo:reference id="demoService"
                     interface="com.tian.dubbo.service.DemoService"
     url="dubbo://127.0.0.1:20880/com.tian.dubbo.service.DemoService"/>
</beans>

🎜 Kemudian buatkannya ke dalam balang dan tambahkannya pada pom.xml pergantungan, dua kali terakhir boleh digunakan. 🎜

provider

🎜Dalam direktori sumber Buat direktori di bawah META-INF.spring , dan kemudian buat application.xml</code >, kandungannya adalah seperti berikut: 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class='brush:php;toolbar:false;'>package com.tian.dubbo; import com.tian.dubbo.service.DemoService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class ConsumerMain { public static void main(String[] args) { DemoService demoService = null; ApplicationContext context = new ClassPathXmlApplicationContext (&quot;classpath:META-INF/spring/application.xml&quot;); demoService = context.getBean(DemoService.class); //调用服务 System.out.println(demoService.sayHello(&quot;tian&quot;)); } }</pre><div class="contentsignin">Salin selepas log masuk</div></div><div class="contentsignin">Salin selepas log masuk</div></div>🎜Buat fail konfigurasi pencetakan log dalam direktori sumber: <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin - kiri: 2px;warna latar belakang: rgba(27, 31, 35, 0.05); keluarga fon: "Operator Mono", Consolas, Monaco, Menlo, monospace;patah perkataan: break-all;warna: rgb(239 , 112, 96);">log4j.properties🎜

<dependency>
     <groupId>org.apache.dubbo</groupId>
     <artifactId>dubbo-dependencies-zookeeper</artifactId>
     <version>3.0.4</version>
     <type>pom</type>
</dependency>

🎜 sedang mentakrifkan kelas pelaksanaan perniagaan: DemoServiceImpl🎜

<dubbo:registry address="N/A"/>

🎜Kemudian tentukan kelas permulaan pembekal: PenyediaUtama🎜

package com.tian.dubbo;

import org.apache.dubbo.container.Main;

public class ProviderMain {
    public static void main(String[] args) {
        Main.main(args);
    }
}

注意：这里的Main类是Dubbo

最后，我们启动ProviderMain类，日志输出：

好了，已经启动成功了。

我们继续来看看consumer项目，在项目中，也就是调用我们服务的项目。

consumer

在consumer项目中application.xml配置文件和provider有所区别。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 服务名称-->
    <dubbo:application name="dubbo-consumer"/>
    <!--不需要注册到服务注册中心--> 
    <!-- 通过url直接调用-->
    <dubbo:reference id="demoService"
                     interface="com.tian.dubbo.service.DemoService"
     url="dubbo://127.0.0.1:20880/com.tian.dubbo.service.DemoService"/>
</beans>

这个url地址，我们在provider启动的时候，可以从日志中找到。

日志文件和provider一样，然后就是ConsumerMain启动类了。

package com.tian.dubbo;

import com.tian.dubbo.service.DemoService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ConsumerMain {
    public static void main(String[] args) {
        DemoService demoService = null;
        ApplicationContext context = new ClassPathXmlApplicationContext
                ("classpath:META-INF/spring/application.xml");
        demoService = context.getBean(DemoService.class);
        //调用服务
        System.out.println(demoService.sayHello("tian"));
    }
}

前面，我们已经把provider成功启动了，下面我们就来启动ConsumerMain。

从日志可以看出我们已经成功调用了provider，我们再来看看provider的日志输出：

也成功的输出了我们想要的。

到此，一个简单的入门无注册中心（通过url直接调用）的方式就完成了。

url masih sangat berguna apabila membangunkan penyahpepijatan bersama, kerana ia menghilangkan pergantungan pada pusat pendaftaran.

demo case 2

Sebelum ini kami sudah berdemo tanpa pusat pendaftaran, kini kami akan berdemo dengan pusat pendaftaran.

Dubbo kini boleh menyokong hampir semua perkara di pasaran Semua pusat pendaftaran: Dubbo目前差不多能支持市面上所有的注册中心：

• consul
• zookeeper
• eureka
• redis
• etcd
• nacos
• ....

我们在实际开发中，Dubbo注册中心大部分都是使用Zookeeper和Nacos。

下面们基于Zookeeper

< li>
consul
• zookeeper
• eureka
• redis
• etcd
• nacos
• ....

Dalam pembangunan sebenar, < gaya kod ="font-size: 14px; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font- family: "Operator Mono", Consolas, Monaco, Menlo, monospace: break-all color: rgb(239, 112, 96);">Dubbo Kebanyakan pusat pendaftaran menggunakan Zookeeper dan Nacos.

Yang berikut adalah berdasarkan Zookeeper to menunjukkan (Nacos adalah serupa, yang akan disebutkan di bawah).

Tahap kod🎜🎜Saya ubah suai berdasarkan kes sebelumnya. Transformasi hanya perlu menyesuaikan dua tempat: 🎜

• consumer和provider中添加pom依赖
• application.xml中添加注册中心

pom依赖

我们需要在前面demo中consumer和provider的pom.xml中添加Zookeeper的依赖：

<dependency>
     <groupId>org.apache.dubbo</groupId>
     <artifactId>dubbo-dependencies-zookeeper</artifactId>
     <version>3.0.4</version>
     <type>pom</type>
</dependency>

provider端

在provider项目中我们需要调整：

<dubbo:registry address="N/A"/>

改成：

<dubbo:registry address="zookeeper://127.0.0.1:2181" timeout="10000"/>

这个timeout建议配上，我这里其实没必要配，因为dubbo服务和Zookeeper都在我本地。

然后我们启动provider项目：

看到我们的项目已经启动成功，并且已经注册到Zookeeper上了。

我们可以使用Zookeeper的可视化工具，看看注册上去的信息。

我们再看看consumer端的调整。

consumer端

我们需要在application.xml中添加

<dubbo:registry address="zookeeper://127.0.0.1:2181" timeout="10000"/>

同时，去掉reference中的url：

<dubbo:reference id="demoService"
                     interface="com.tian.dubbo.service.DemoService"
     url="dubbo://127.0.0.1:20880/com.tian.dubbo.service.DemoService"/>

因为是通过Zookeeper注册中心拿到地址，所以这里的url就可以去掉了。

最后，启动ConsumerMain类：

可以看到我们也成功调用服务，另外也有大量的Zookeeper日志。

到此，说明，我们的Zookeeper为注册中心的demo案例也成功了。

注意：provider和consumer项目都需要依赖相关jar包（api、zookeeper、dubbo）

其他

关于Nacos，我们这里就不演示了，因为太简单了，如果你把Nacos搭建好了后，直接配置就好了。

<dubbo:registry address="nacos://127.0.0.1:8848" timeout="10000"/>

就是把address地址改一下就可以了。

Nacos 的演示，我们下一篇文章中见。

总结

本文分享了Dubbo入门案例的两个版本：无注册中心和Zookeeper注册中心。

Atas ialah kandungan terperinci Analisis kod sumber Dubbo: Panduan pemula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!