This is an automated email from the ASF dual-hosted git repository.
liujun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/dubbo-website.git
The following commit(s) were added to refs/heads/master by this push:
new 059e2f5b0e proxy dubbo in apache shenyu (#1082)
059e2f5b0e is described below
commit 059e2f5b0e7cc4baacefef3ed18e8d8ae64112cf
Author: midnight2104 <[email protected]>
AuthorDate: Mon May 9 16:38:44 2022 +0800
proxy dubbo in apache shenyu (#1082)
---
.../news/how-to-proxy-dubbo-in-apache-shenyu.md | 401 ++++++++++++++++++++
.../news/how-to-proxy-dubbo-in-apache-shenyu.md | 411 +++++++++++++++++++++
.../imgs/blog/shenyu-dubbo/ApacheDubboPlugin.png | Bin 0 -> 14832 bytes
.../blog/shenyu-dubbo/ApacheShenYu-Dubbo-en.png | Bin 0 -> 128630 bytes
.../blog/shenyu-dubbo/ApacheShenYu-Dubbo-zh.png | Bin 0 -> 113271 bytes
static/imgs/blog/shenyu-dubbo/MessageWriter.png | Bin 0 -> 15626 bytes
.../ShenyuClientRegisterDubboServiceImpl.png | Bin 0 -> 26691 bytes
static/imgs/blog/shenyu-dubbo/data-sync-seq-en.png | Bin 0 -> 58201 bytes
static/imgs/blog/shenyu-dubbo/data-sync-seq-zh.png | Bin 0 -> 93305 bytes
static/imgs/blog/shenyu-dubbo/data-sync.png | Bin 0 -> 83529 bytes
static/imgs/blog/shenyu-dubbo/dubbo-enable-en.png | Bin 0 -> 138868 bytes
static/imgs/blog/shenyu-dubbo/dubbo-enable-zh.png | Bin 0 -> 147345 bytes
static/imgs/blog/shenyu-dubbo/dubbo-execute-en.png | Bin 0 -> 55691 bytes
static/imgs/blog/shenyu-dubbo/dubbo-execute-zh.png | Bin 0 -> 72315 bytes
.../imgs/blog/shenyu-dubbo/dubbo-register-en.png | Bin 0 -> 61502 bytes
.../imgs/blog/shenyu-dubbo/dubbo-register-zh.png | Bin 0 -> 65742 bytes
static/imgs/blog/shenyu-dubbo/dubbo-rule-en.png | Bin 0 -> 135915 bytes
static/imgs/blog/shenyu-dubbo/dubbo-rule-zh.png | Bin 0 -> 129569 bytes
.../imgs/blog/shenyu-dubbo/dubbo-selector-en.png | Bin 0 -> 136569 bytes
.../imgs/blog/shenyu-dubbo/dubbo-selector-zh.png | Bin 0 -> 123354 bytes
.../blog/shenyu-dubbo/dubbo-service-list-en.png | Bin 0 -> 178276 bytes
.../blog/shenyu-dubbo/dubbo-service-list-zh.png | Bin 0 -> 189937 bytes
static/imgs/blog/shenyu-dubbo/register-client.png | Bin 0 -> 70104 bytes
static/imgs/blog/shenyu-dubbo/register-server.png | Bin 0 -> 215477 bytes
static/imgs/blog/shenyu-dubbo/shenyu.png | Bin 0 -> 238554 bytes
25 files changed, 812 insertions(+)
diff --git a/content/en/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
b/content/en/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
new file mode 100644
index 0000000000..f3e925fe3c
--- /dev/null
+++ b/content/en/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
@@ -0,0 +1,401 @@
+---
+title: "How to proxy Dubbo service in Apache ShenYu Gateway"
+linkTitle: "How to proxy Dubbo service in Apache ShenYu Gateway"
+date: 2022-05-04
+description: This article describes how to access the `Dubbo` service through
the `Apache ShenYu` gateway. The main content includes a simple example to core
call flow analysis and a summary of the design principles.
+---
+
+
+
+
+## 1. Introduction
+
+- Apache ShenYu
+
+
+
+
+[Apache ShenYu(Incubating)](https://shenyu.apache.org/docs/index) is an
asynchronous, high-performance, cross-language, responsive `API` gateway.
Compatible with a variety of mainstream framework systems, support for
hot-plugging, users can customize the development to meet the current and
future needs of users in a variety of scenarios, experienced large-scale
scenarios hammered.
+
+In May 2021, `ShenYu` was donated to the `Apache` Software Foundation, and the
Apache Foundation voted unanimously to enter the incubator.
+
+- Apache Dubbo
+
+`Apache Dubbo` is a microservice development framework that provides two key
capabilities, `RPC` communication and microservice governance. This means that
microservices developed with `Dubbo` will have the ability to discover and
communicate with each other remotely, and take advantage of the rich service
governance capabilities provided by Dubbo to achieve service governance
requirements such as service discovery, load balancing, traffic scheduling, and
so on. At the same time `Dubbo` [...]
+
+## 2. Quick Start with Dubbo
+
+This section describes how to connect the `Dubbo` service to the `Shenyu`
gateway. You can find the [sample code] for this section directly under the
project
(https://github.com/apache/incubator-shenyu/tree/master/shenyu-examples/shenyu
-examples-dubbo/shenyu-examples-apache-dubbo-service).
+
+### 2.1 Start shenyu-admin
+
+`shenyu-admin` is the `Apache ShenYu` backend management system, there are
various ways to start it, this article is started by [local
deployment](https://shenyu.apache.org/docs/deployment/deployment-local) way.
After successful startup, you need to set the `dubbo` plugin to be on and set
your registered address in the base configuration `->`Plugin Management',
please make sure the registration center has been opened.
+
+
+
+### 2.2 Start ShenYu Gateway
+
+Here it is started by way of
[source](https://github.com/apache/incubator-shenyu/tree/master/shenyu-bootstrap)
and runs directly `shenyu-bootstrap` in `shenyu-bootstrap`.
ShenyuBootstrapApplication`.
+
+Make sure the gateway has introduced the relevant dependencies before
starting. If the client is `apache dubbo` and the registry uses `zookeeper`,
please refer to the following configuration.
+
+```java
+ <!-- apache shenyu apache dubbo plugin start-->
+ <dependency>
+ <groupId>org.apache.shenyu</groupId>
+
<artifactId>shenyu-spring-boot-starter-plugin-apache-dubbo</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.dubbo</groupId>
+ <artifactId>dubbo</artifactId>
+ <version>2.7.5</version>
+ </dependency>
+ <!-- Dubbo zookeeper registry dependency start -->
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-client</artifactId>
+ <version>4.0.1</version>
+ <exclusions>
+ <exclusion>
+ <artifactId>log4j</artifactId>
+ <groupId>log4j</groupId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-framework</artifactId>
+ <version>4.0.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-recipes</artifactId>
+ <version>4.0.1</version>
+ </dependency>
+ <!-- Dubbo zookeeper registry dependency end -->
+ <!-- apache dubbo plugin end-->
+```
+
+### 2.3 Start shenyu-examples-dubbo
+
+Take the example provided on the official website
[shenyu-examples-dubbo](https://github.com/apache/incubator-shenyu/tree/master/shenyu-examples/shenyu-examples-dubbo/shenyu-examples-apache-dubbo-service).
Suppose the `dubbo` service is defined as follows.
+
+```xml
+<beans /* ...... * />
+
+ <dubbo:application name="test-dubbo-service"/>
+ <dubbo:registry address="${dubbo.registry.address}"/>
+ <dubbo:protocol name="dubbo" port="20888"/>
+
+ <dubbo:service timeout="10000"
interface="org.apache.shenyu.examples.dubbo.api.service.DubboTestService"
ref="dubboTestService"/>
+
+</beans>
+```
+
+Declare the application service name, register the center address, use the
`dubbo` protocol, declare the service interface, and the corresponding
interface implementation class.
+
+```java
+/**
+ * DubboTestServiceImpl.
+ */
+@Service("dubboTestService")
+public class DubboTestServiceImpl implements DubboTestService {
+
+ @Override
+ @ShenyuDubboClient(path = "/findById", desc = "Query by Id")
+ public DubboTest findById(final String id) {
+ return new DubboTest(id, "hello world shenyu Apache, findById");
+ }
+
+ //......
+}
+```
+
+In the interface implementation class, use the annotation `@ShenyuDubboClient`
to register the service with `shenyu-admin`.
+
+Configuration information in the configuration file `application.yml`.
+
+```yaml
+server:
+ port: 8011
+ address: 0.0.0.0
+ servlet:
+ context-path: /
+spring:
+ main:
+ allow-bean-definition-overriding: true
+dubbo:
+ registry:
+ address: zookeeper://localhost:2181 # The registry used by dubbo
+
+shenyu:
+ register:
+ registerType: http #Registration Method
+ serverLists: http://localhost:9095 #Registration Address
+ props:
+ username: admin
+ password: 123456
+ client:
+ dubbo:
+ props:
+ contextPath: /dubbo
+ appName: dubbo
+
+```
+
+In the configuration file, declare the registry address used by `dubbo`. The
`dubbo` service registers with `shenyu-admin`, using the method `http`, and the
registration address is `http://localhost:9095`.
+
+See [Application Client
Access](https://shenyu.apache.org/docs/design/register-center-design/) for more
information on the use of the registration method.
+
+
+### 2.4 Invoke the Dubbo service
+
+The `shenyu-examples-dubbo` project will automatically register the interface
methods annotated with `@ShenyuDubboClient` to the gateway after it is
successfully started.
+
+Open `Plugins List -> Proxy -> dubbo` to see the list of plugin rules
configuration.
+
+
+
+Information on the selectors for successful registration.
+
+
+
+Information on the rules for successful registration.
+
+
+
+> Selectors and rules are the soul of the `Apache ShenYu` gateway. Mastering
it well, you can manage any traffic. Corresponding to the matching conditions
(conditions) inside the selectors and rules, we can handle various complex
scenarios according to different traffic filtering rules. Traffic filtering can
get data from `Header`, `URI`, `Query`, `Cookie` and so on Http requests.
+>
+> Then you can use `Match`, `=`, `Regex`, `Groovy`, `Exclude` and other
matching methods to match the data you expect. Multi-group match additions can
use the `And/Or` matching strategy.
+>
+> See: [Selector and Rule
Management](https://shenyu.apache.org/docs/user-guide/admin-usage/selector-and-rule)
for details and usage.
+
+
+Initiate a `GET` request to invoke the `dubbo` service through the `ShenYu`
gateway.
+
+```
+GET http://localhost:9195/dubbo/findById?id=100
+Accept: application/json
+```
+
+After a successful response, the result is as follows.
+
+```
+{
+ "name": "hello world shenyu Apache, findById",
+ "id": "100"
+}
+```
+
+At this point, you can successfully access the `dubbo` service via `http`
requests. The `ShenYu` gateway converts the `http` protocol to the `dubbo`
protocol via the `shenyu-plugin-dubbo` module.
+
+## 3. Understanding of Dubbo plugin
+
+During the process of running the above `demo`, are there any questions about
+
+- How does the `dubbo` service register with `shenyu-admin`?
+- How does `shenyu-admin` synchronize data to the `ShenYu` gateway?
+- How does the `DubboPlugin` convert the `http` protocol to the `dubbo`
protocol?
+
+With these questions in mind, let's dive into understanding the `dubbo` plugin.
+
+### 3.1 Application Client Access
+
+Application client access refers to accessing microservices to the `Apache
ShenYu` gateway, which currently supports access to `Http`, `Dubbo`, `Spring
Cloud`, `gRPC`, `Motan`, `Sofa`, `Tars` and other protocols.
+
+Accessing application clients to the `Apache ShenYu` gateway is achieved
through the registry, which involves client-side registration and server-side
synchronization of data. The registry supports `Http`, `Zookeeper`, `Etcd`,
`Consul` and `Nacos`. The default is to register by `Http`.
+
+Please refer to [Client Access
Configuration](https://shenyu.apache.org/docs/user-guide/register-center-access)
for client access related configuration.
+
+#### 3.1.1 Client-side Registration
+
+
+
+Declare the registry client type, such as `Http` or `Zookeeper`, in your
microservice configuration.
+Load and initialize the corresponding registry client using the `SPI` method
when the application starts, and get the service interface information that
needs to be registered in it by implementing the post-processor interface
related to the `Spring Bean`, and put the obtained information into the
`Disruptor`.
+
+The registry client reads the data from `Disruptor` and registers the
interface information to `shenyu-admin`, where `Disruptor` plays the role of
decoupling data and operations, which is convenient for extension.
+
+#### 3.1.2 Server-side Registration
+
+
+
+Declare the registry server type, such as `Http` or `Zookeeper`, in the
`shenyu-admin` configuration. When `shenyu-admin` starts, it will read the
configuration type, load and initialize the corresponding registry server, and
when the registry server receives the interface information registered by
`shenyu-client`, it will put it into `Disruptor`, and then it will trigger the
registration processing logic to update the service interface information and
publish the synchronization event.
+
+The `Disruptor` plays a role in decoupling data and operation, which is good
for extension. It also has a data buffering role if too many registration
requests lead to registration exceptions.
+
+### 3.2 Data Synchronization Principle
+
+Data synchronization refers to the policy used to synchronize data to the
`Apache ShenYu` gateway after the `shenyu-admin` backend has manipulated the
data. The `Apache ShenYu` gateway currently supports `ZooKeeper`, `WebSocket`,
`Http long polling`, `Nacos`, `Etcd` and `Consul` for data synchronization. The
default is to synchronize data via `WebSocket`.
+
+Please refer to [Data Synchronization
Configuration](https://shenyu.apache.org/docs/user-guide/use-data-sync) for the
configuration of data synchronization.
+
+#### 3.2.1 The Significance of Data Synchronization
+
+The gateway is the entry point for traffic requests and plays a very important
role in the microservices architecture, and the importance of high availability
of the gateway is self-evident. In the process of using the gateway, in order
to meet the business requirements, it is often necessary to change the
configuration, such as flow control rules, routing rules and so on. Therefore,
the dynamic configuration of the gateway is an important factor to ensure the
high availability of the gateway.
+
+The current data synchronization characteristics are as follows.
+
+- All configurations are cached in the `Apache ShenYu` gateway memory, and
each request uses the local cache, which is very fast.
+- Users can change any data in the `shenyu-admin` backend and it will be
synchronized to the gateway memory immediately.
+- Supports data synchronization of plugins, selectors, rule data, metadata,
signature data, etc. for `Apache ShenYu`.
+- All plug-in selectors and rules are dynamically configured and take effect
immediately, without restarting the service.
+- Data synchronization method supports `Zookeeper`, `Http long polling`,
`Websocket`, `Nacos`, `Etcd` and `Consul`.
+
+#### 3.2.2 Data Synchronization Principle Analysis
+
+The following diagram shows the flow of `Apache ShenYu` data synchronization.
The `Apache ShenYu` gateway synchronizes configuration data from the
configuration service when it starts, and supports push-pull mode to get
configuration change information and then update the local cache.
Administrators can change user permissions, rules, plugins, traffic
configuration in the administration backend (`shenyu-admin`) and synchronize
the changes to the `Apache ShenYu` gateway via push-pull mode [...]
+
+
+
+In the original version, the configuration service relied on the `Zookeeper`
implementation, and the management backend `pushed` the changes to the gateway.
Now we can support `WebSocket`, `Http long polling`, `Zookeeper`, `Nacos`,
`Etcd` and `Consul`, by setting `shenyu.sync.${strategy}` in the configuration
file to specify the corresponding synchronization strategy, the default is to
use `webosocket` synchronization strategy to achieve second-level data
synchronization. However, one th [...]
+
+As shown in the figure below, `shenyu-admin` sends out configuration change
notifications through `EventPublisher` after a user makes a configuration
change, and `EventDispatcher` processes the change notification, and then
synchronizes the data according to the configured synchronization policy
(`http, weboscket, zookeeper, naocs, etcd, consul`). etcd, consul`), the
configuration is sent to the corresponding event handler.
+
+- If it is a `websocket` synchronization policy, the changed data will be
actively pushed to `shenyu-web` and there will be a corresponding
`WebsocketDataHandler` processor at the gateway layer to handle the data push
from `shenyu-admin`.
+- In case of `zookeeper` synchronization policy, the change data will be
updated to `zookeeper`, and `ZookeeperSyncCache` will listen to `zookeeper`
data changes and process them.
+- In case of `http` synchronization policy, the gateway initiates a long
polling request with `90s` timeout by default, if `shenyu-admin` has no data
change, it will block the `http` request, if there is data change, it will
respond with the changed data information, if more than `60s` there is still no
data change, it will respond with empty data, after the gateway layer receives
the response After receiving the response, the gateway layer continues to make
`http` requests, repeating th [...]
+
+### 3.3 Process Analysis
+
+The process analysis shows the service registration process, data
synchronization process and service invocation process from the source code
perspective.
+
+#### 3.3.1 Service Registration Process
+
+- Reading dubbo services
+
+Use the annotation `@ShenyuDubboClient` to mark `dubbo` services that need to
be registered to the gateway.
+
+Annotation scanning is done via the `ApacheDubboServiceBeanListener`, which
implements the `ApplicationListener<ContextRefreshedEvent>` interface and
starts executing the event handler method when a context refresh event occurs
during the `Spring` container startup `onApplicationEvent()`. In the rewritten
method logic, the `Dubbo` service `ServiceBean` is read, the metadata object
and the `URI` object are constructed and registered with `shenyu-admin`.
+
+The specific registration logic is implemented by the registry, please refer
to [Client Access
Principles](https://shenyu.apache.org/docs/design/register-center-design/) .
+
+- Processing registration information
+
+The metadata and `URI` data registered by the client through the registration
center are processed at the `shenyu-admin` end, which is responsible for
storing to the database and synchronizing to the `shenyu` gateway. The
client-side registration processing logic of the `Dubbo` plugin is in the
`ShenyuClientRegisterDubboServiceImpl`. The inheritance relationship is as
follows.
+
+
+
+- ShenyuClientRegisterService: client registration service, top-level
interface.
+- FallbackShenyuClientRegisterService: registration failure, provides retry
operation.
+- AbstractShenyuClientRegisterServiceImpl: abstract class, implements part of
the public registration logic.
+- ShenyuClientRegisterDubboServiceImpl: implements the registration of `Dubbo`
plug-ins.
+
+Registration information including selectors, rules and metadata.
+
+The overall `dubbo` service registration process is as follows.
+
+
+
+#### 3.3.2 Data Synchronization Process
+
+- admin update data
+
+Suppose in the backend management system, a new selector data is added, the
request goes to the `createSelector()` method in the `SelectorController`
class, which is responsible for verifying the data, adding or updating the
data, and returning the result information.
+
+In the `SelectorServiceImpl` class, the `createOrUpdate()` method completes
the conversion of the data, saves it to the database, publishes events, and
updates the `upstream`.
+
+Persistence of data is done in the `Service` class, i.e. saving data to the
database. Publishing the changed data is done by
`eventPublisher.publishEvent()`, the `eventPublisher` object is an
`ApplicationEventPublisher` class, the fully qualified name of this class is
`org.springframework. ApplicationEventPublisher`, the function of publishing
data is exactly what is done through `Spring` related functions.
+
+When the event is published, it automatically goes to the
`onApplicationEvent()` method in the `DataChangedEventDispatcher` class, which
handles the event according to the different data types and data
synchronization methods.
+
+- Gateway data synchronization
+
+At startup, the gateway loads different configuration classes and initializes
data synchronization-related classes according to the specified data
synchronization method.
+
+After receiving the data, it performs deserialization operation to read the
data type and operation type. Different data types have different data
processing methods, so there are different implementation classes. But they
also have the same processing logic between them, so they can be implemented by
template method design pattern. The same logic is put in the `handle()` method
in the abstract class `AbstractDataHandler`, and the different logic is given
to the respective implementation [...]
+
+Adding a new selector data is a new operation that goes to the
`SelectorDataHandler.doUpdate()` concrete data processing logic.
+
+In the common plugin data subscriber `CommonPluginDataSubscriber`, which is
responsible for handling all plugin, selector and rule information
+
+Saves data to the gateway's memory, `BaseDataCache` is the class that
ultimately caches the data, implemented through the singleton pattern. The
selector data is then stored in `SELECTOR_MAP`, a `Map`. In the subsequent use,
the data is also taken from here.
+
+The above logic is represented in a flowchart as follows.
+
+
+
+#### 3.3.3 Service Invocation Process
+
+In the `Dubbo` plugin system, the class extends relationship is as follows.
+
+
+
+> ShenyuPlugin: top-level interface, defining interface methods.
+>
+> AbstractShenyuPlugin: abstract class that implements the common logic of the
plugin; > AbstractShenyuPlugin: abstract class that implements the common logic
of the plugin.
+>
+> AbstractDubboPlugin: dubbo plug-in abstract class, implementing `dubbo`
common logic (ShenYu gateway supports ApacheDubbo and AlibabaDubbo).
+>
+> ApacheDubboPlugin: ApacheDubbo plugin.
+
+
+-
org.apache.shenyu.web.handler.ShenyuWebHandler.DefaultShenyuPluginChain#execute()
+
+After passing the `ShenYu` gateway proxy, the request entry is
`ShenyuWebHandler`, which implements the
`org.springframework.web.server.WebHandler` interface and connects all plugins
through the chain-of-responsibility design pattern.
+
+- org.apache.shenyu.plugin.base.AbstractShenyuPlugin#execute()
+
+Determining whether a plugin is executed when a request is made to the gateway
is done by the specified matching logic. The matching logic for selectors and
rules is executed in the `execute()` method.
+
+- org.apache.shenyu.plugin.global.GlobalPlugin#execute()
+
+The first to be executed is the `GlobalPlugin` , which is a global plugin that
constructs contextual information in the `execute()` method.
+
+- org.apache.shenyu.plugin.base.RpcParamTransformPlugin#execute()
+
+Next to be executed is the `RpcParamTransformPlugin`, which is responsible for
reading the parameters from the `http` request, saving them in the `exchange`
and passing them to the `rpc` service. In the `execute()` method, the core
logic of the plugin is executed: it gets the request information from
`exchange` and processes the parameters according to the form of the content
passed in the request.
+
+
+- org.apache.shenyu.plugin.dubbo.common.AbstractDubboPlugin
+
+Then what gets executed is the `DubboPlugin` . In the `doExecute()` method,
the main focus is on checking metadata and parameters. In the
`doDubboInvoker()` method, special context information is set and then the
generalized invocation of `dubbo` is started.
+
+In the `genericInvoker()` method.
+
+- Gets the `ReferenceConfig` object.
+- obtains the generalization service `GenericService` object.
+- Constructs the request parameter `pair` object.
+- Initiate an asynchronous generalization invocation.
+
+The generalization call enables you to call the `dubbo` service at the gateway.
+
+The `ReferenceConfig` object is the key object that supports generalization
calls, and its initialization is done during data synchronization.
+
+- org.apache.shenyu.plugin.response.ResponsePlugin#execute()
+
+The last one to be executed is `ResponsePlugin`, which unifies the response
result messages of the gateway. The processing type is determined by the
`MessageWriter`, and the class extends relationship is as follows.
+
+
+
+> MessageWriter: interface that defines message processing methods.
+>
+> NettyClientMessageWriter: Handles the results of `Netty` calls.
+>
+> RPCMessageWriter: processing the results of `RPC` calls.
+>
+> WebClientMessageWriter: processing the results of `WebClient` calls;
+
+The `Dubbo` service is called and the result of processing is the
`RPCMessageWriter`.
+
+- org.apache.shenyu.plugin.response.strategy.RPCMessageWriter#writeWith()
+
+Process the response results in the `writeWith()` method, get the results or
handle exceptions.
+
+At this point in the analysis, the source code analysis of the `Dubbo` plugin
is complete, and the analysis flowchart is as follows.
+
+
+
+
+
+## 4. Summary
+
+This article analyzes the proxy process of `ShenYu` gateway to Dubbo service
from a practical case. The main knowledge points involved are as follows.
+
+- Implementing plug-ins through the chain-of-responsibility design pattern.
+- implementing `AbstractShenyuPlugin` using the template method design pattern
to handle generic operation types.
+- implementation of the cached data class `BaseDataCache` using the singleton
design pattern.
+- the ability to introduce different registries and number synchronization
methods through the `springboot starter`, which is very scalable.
+- support for hot updates of rules through `admin` to facilitate traffic
control.
+- `Disruptor` queue is for data and operation decoupling, as well as data
buffering.
diff --git a/content/zh/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
b/content/zh/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
new file mode 100644
index 0000000000..e924d55d73
--- /dev/null
+++ b/content/zh/blog/news/how-to-proxy-dubbo-in-apache-shenyu.md
@@ -0,0 +1,411 @@
+---
+title: "如何通过 Apache ShenYu 网关代理 Dubbo 服务"
+linkTitle: "如何通过 Apache ShenYu 网关代理 Dubbo 服务"
+date: 2022-05-04
+description: >
+ 本文介绍了如何通过`Apache ShenYu`网关访问`Dubbo`服务，主要内容包括从简单示例到核心调用流程分析，并对设计原理进行了总结。
+---
+
+
+
+
+## 1. 介绍
+
+- Apache ShenYu
+
+
+
+
+[Apache ShenYu(Incubating)](https://shenyu.apache.org/zh/docs/index)
是一个异步的，高性能的，跨语言的，响应式的 `API`
网关。兼容各种主流框架体系，支持热插拔，用户可以定制化开发，满足用户各种场景的现状和未来需求，经历过大规模场景的锤炼。
+
+2021年5月，`ShenYu`捐献给 `Apache` 软件基金会，Apache 基金会全票通过，顺利进入孵化器。
+
+
+- Apache Dubbo
+
+`Apache Dubbo` 是一款微服务开发框架，它提供了 `RPC` 通信 与 微服务治理 两大关键能力。这意味着，使用 `Dubbo`
开发的微服务，将具备相互之间的远程发现与通信能力， 同时利用 Dubbo 提供的丰富服务治理能力，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。同时
`Dubbo` 是高度可扩展的，用户几乎可以在任意功能点去定制自己的实现，以改变框架的默认行为来满足自己的业务需求。
+
+
+## 2. Dubbo快速开始
+
+本小节介绍如何将`Dubbo`服务接入到`ShenYu`网关，您可以直接在工程下找到本小节的[示例代码](https://github.com/apache/incubator-shenyu/tree/master/shenyu-examples/shenyu-examples-dubbo/shenyu-examples-apache-dubbo-service)
。
+
+
+### 2.1 启动shenyu-admin
+
+`shenyu-admin`是`Apache ShenYu`后台管理系统， 启动的方式有多种，本文通过
[本地部署](https://shenyu.apache.org/zh/docs/deployment/deployment-local)
的方式启动。启动成功后，需要在基础配置`->`插件管理中，把`dubbo` 插件设置为开启，并设置你的注册地址，请确保注册中心已经开启。
+
+
+
+
+### 2.2 启动shenyu网关
+
+在这里通过
[源码](https://github.com/apache/incubator-shenyu/tree/master/shenyu-bootstrap)
的方式启动，直接运行`shenyu-bootstrap`中的`ShenyuBootstrapApplication`。
+
+在启动前，请确保网关已经引入相关依赖。如果客户端是`apache dubbo`，注册中心使用`zookeeper`，请参考如下配置：
+
+```java
+ <!-- apache shenyu apache dubbo plugin start-->
+ <dependency>
+ <groupId>org.apache.shenyu</groupId>
+
<artifactId>shenyu-spring-boot-starter-plugin-apache-dubbo</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.dubbo</groupId>
+ <artifactId>dubbo</artifactId>
+ <version>2.7.5</version>
+ </dependency>
+ <!-- Dubbo zookeeper registry dependency start -->
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-client</artifactId>
+ <version>4.0.1</version>
+ <exclusions>
+ <exclusion>
+ <artifactId>log4j</artifactId>
+ <groupId>log4j</groupId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-framework</artifactId>
+ <version>4.0.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.curator</groupId>
+ <artifactId>curator-recipes</artifactId>
+ <version>4.0.1</version>
+ </dependency>
+ <!-- Dubbo zookeeper registry dependency end -->
+ <!-- apache dubbo plugin end-->
+```
+
+### 2.3 启动shenyu-examples-dubbo
+
+以官网提供的例子为例
[shenyu-examples-dubbo](https://github.com/apache/incubator-shenyu/tree/master/shenyu-examples/shenyu-examples-dubbo/shenyu-examples-apache-dubbo-service)
。 假如`dubbo`服务定义如下：
+
+```xml
+<beans /* ...... * />
+
+ <dubbo:application name="test-dubbo-service"/>
+ <dubbo:registry address="${dubbo.registry.address}"/>
+ <dubbo:protocol name="dubbo" port="20888"/>
+
+ <dubbo:service timeout="10000"
interface="org.apache.shenyu.examples.dubbo.api.service.DubboTestService"
ref="dubboTestService"/>
+
+</beans>
+```
+
+声明应用服务名称，注册中心地址，使用`dubbo`协议，声明服务接口，对应接口实现类：
+
+```java
+/**
+ * DubboTestServiceImpl.
+ */
+@Service("dubboTestService")
+public class DubboTestServiceImpl implements DubboTestService {
+
+ @Override
+ @ShenyuDubboClient(path = "/findById", desc = "Query by Id")
+ public DubboTest findById(final String id) {
+ return new DubboTest(id, "hello world shenyu Apache, findById");
+ }
+
+ //......
+}
+```
+
+在接口实现类中，使用注解`@ShenyuDubboClient`向`shenyu-admin`注册服务。
+
+在配置文件`application.yml`中的配置信息：
+
+```yaml
+server:
+ port: 8011
+ address: 0.0.0.0
+ servlet:
+ context-path: /
+spring:
+ main:
+ allow-bean-definition-overriding: true
+dubbo:
+ registry:
+ address: zookeeper://localhost:2181 # dubbo使用的注册中心
+
+shenyu:
+ register:
+ registerType: http #注册方式
+ serverLists: http://localhost:9095 #注册地址
+ props:
+ username: admin
+ password: 123456
+ client:
+ dubbo:
+ props:
+ contextPath: /dubbo
+ appName: dubbo
+
+```
+
+在配置文件中，声明`dubbo`使用的注册中心地址，`dubbo`服务向`shenyu-admin`注册，使用的方式是`http`，注册地址是`http://localhost:9095`。
+
+关于注册方式的使用，请参考
[应用客户端接入](https://shenyu.apache.org/docs/design/register-center-design/) 。
+
+
+### 2.4 调用dubbo服务
+
+`shenyu-examples-dubbo`项目成功启动之后会自动把加 `@ShenyuDubboClient` 注解的接口方法注册到网关。
+
+
+打开 `插件列表 -> Proxy -> dubbo` 可以看到插件规则配置列表：
+
+
+
+
+注册成功的选择器信息：
+
+
+
+注册成功的规则信息：
+
+
+
+> 选择器和规则是 `Apache ShenYu`
网关中最灵魂的东西。掌握好它，你可以对任何流量进行管理。对应为选择器与规则里面的匹配条件(conditions)，根据不同的流量筛选规则，我们可以处理各种复杂的场景。流量筛选可以从`Header`,
`URI`, `Query`, `Cookie` 等等Http请求获取数据。
+>
+> 然后可以采用
`Match`，`=`，`Regex`，`Groovy`，`Exclude`等匹配方式，匹配出你所预想的数据。多组匹配添加可以使用`And/Or`的匹配策略。
+>
+> 具体的介绍与使用请看:
[选择器与规则管理](https://shenyu.apache.org/zh/docs/design/user-guide/admin-usage/selector-and-rule)
。
+
+
+发起`GET`请求，通过`ShenYu`网关调用`dubbo`服务：
+
+```
+GET http://localhost:9195/dubbo/findById?id=100
+Accept: application/json
+```
+
+成功响应之后，结果如下：
+
+```
+{
+ "name": "hello world shenyu Apache, findById",
+ "id": "100"
+}
+```
+
+至此，就成功的通过`http`请求访问`dubbo`服务了，`ShenYu`网关通过`shenyu-plugin-dubbo`模块将`http`协议转成了`dubbo`协议。
+
+
+## 3. 深入理解Dubbo插件
+
+在运行上述`demo`的过程中，是否存在一些疑问：
+
+- `dubbo`服务是如何注册到`shenyu-admin`？
+- `shenyu-admin`是如何将数据同步到`ShenYu`网关？
+- `DubboPlugin`是如何将`http`协议转换到到dubbo协议？
+
+带着这些疑问，来深入理解`dubbo`插件。
+
+
+### 3.1 应用客户端接入
+
+应用客户端接入是指将微服务接入到`Apache ShenYu`网关，当前支持`Http`、 `Dubbo`、 `Spring Cloud`、 `gRPC`、
`Motan`、 `Sofa`、 `Tars`等协议的接入。
+
+将应用客户端接入到`Apache
ShenYu`网关是通过注册中心来实现的，涉及到客户端注册和服务端同步数据。注册中心支持`Http`、`Zookeeper`、`Etcd`、`Consul`和`Nacos`。默认是通过`Http`方式注册。
+
+客户端接入的相关配置请参考
[客户端接入配置](https://shenyu.apache.org/zh/docs/user-guide/register-center-access) 。
+
+#### 3.1.1 客户端注册
+
+
+
+在你的微服务配置中声明注册中心客户端类型，如`Http`或`Zookeeper`。
+应用程序启动时使用`SPI`方式加载并初始化对应注册中心客户端，通过实现`Spring
Bean`相关的后置处理器接口，在其中获取需要进行注册的服务接口信息，将获取的信息放入`Disruptor`中。
+
+注册中心客户端从`Disruptor`中读取数据，并将接口信息注册到`shenyu-admin`，`Disruptor`在其中起数据与操作解耦的作用，利于扩展。
+
+#### 3.1.2 服务端注册
+
+
+
+在`shenyu-admin`配置中声明注册中心服务端类型，如`Http`或`Zookeeper`。当`shenyu-admin`启动时，读取配置类型，加载并初始化对应的注册中心服务端，注册中心服务端收到`shenyu-client`注册的接口信息后，将其放入`Disruptor`中，然后会触发注册处理逻辑，将服务接口信息更新并发布同步事件。
+
+`Disruptor`在其中起到数据与操作解耦，利于扩展。如果注册请求过多，导致注册异常，也有数据缓冲作用。
+
+### 3.2 数据同步原理
+
+数据同步是指在 `shenyu-admin` 后台操作数据以后，使用何种策略将数据同步到 `Apache ShenYu` 网关。`Apache
ShenYu` 网关当前支持`ZooKeeper`、`WebSocket`、`Http长轮询`、`Nacos` 、`Etcd` 和 `Consul`
进行数据同步。默认是通过`WebSocket`进行数据同步。
+
+数据同步的相关配置请参考
[数据同步配置](https://shenyu.apache.org/zh/docs/user-guide/use-data-sync) 。
+
+#### 3.2.1 数据同步的意义
+
+网关是流量请求的入口，在微服务架构中承担了非常重要的角色，网关高可用的重要性不言而喻。在使用网关的过程中，为了满足业务诉求，经常需要变更配置，比如流控规则、路由规则等等。因此，网关动态配置是保障网关高可用的重要因素。
+
+当前数据同步特性如下：
+
+- 所有的配置都缓存在 `Apache ShenYu` 网关内存中，每次请求都使用本地缓存，速度非常快。
+- 用户可以在 `shenyu-admin` 后台任意修改数据，并马上同步到网关内存。
+- 支持 `Apache ShenYu` 的插件、选择器、规则数据、元数据、签名数据等数据同步。
+- 所有插件的选择器，规则都是动态配置，立即生效，不需要重启服务。
+- 数据同步方式支持 `Zookeeper`、`Http 长轮询`、`Websocket`、`Nacos`、`Etcd` 和 `Consul`。
+
+#### 3.2.2 数据同步原理分析
+
+下图展示了 `Apache ShenYu` 数据同步的流程，`Apache ShenYu`
网关在启动时，会从配置服务同步配置数据，并且支持推拉模式获取配置变更信息，然后更新本地缓存。管理员可以在管理后台（`shenyu-admin`），变更用户权限、规则、插件、流量配置，通过推拉模式将变更信息同步给
`Apache ShenYu` 网关，具体是 `push` 模式，还是 `pull` 模式取决于使用哪种同步方式。
+
+
+
+在最初的版本中，配置服务依赖 `Zookeeper` 实现，管理后台将变更信息 `push` 给网关。而现在可以支持
`WebSocket`、`Http长轮询`、`Zookeeper`、`Nacos`、`Etcd` 和 `Consul`，通过在配置文件中设置
`shenyu.sync.${strategy}` 指定对应的同步策略，默认使用 `webosocket`
同步策略，可以做到秒级数据同步。但是，有一点需要注意的是，`Apache ShenYu`网关 和 `shenyu-admin` 必须使用相同的同步策略。
+
+如下图所示，`shenyu-admin` 在用户发生配置变更之后，会通过 `EventPublisher` 发出配置变更通知，由
`EventDispatcher`
处理该变更通知，然后根据配置的同步策略(`http、weboscket、zookeeper、naocs、etcd、consul`)，将配置发送给对应的事件处理器。
+
+- 如果是 `websocket` 同步策略，则将变更后的数据主动推送给 `shenyu-web`，并且在网关层，会有对应的
`WebsocketDataHandler` 处理器来处理 `shenyu-admin` 的数据推送。
+- 如果是 `zookeeper` 同步策略，将变更数据更新到 `zookeeper`，而 `ZookeeperSyncCache` 会监听到
`zookeeper` 的数据变更，并予以处理。
+- 如果是 `http` 同步策略，由网关主动发起长轮询请求，默认有 `90s` 超时时间，如果 `shenyu-admin` 没有数据变更，则会阻塞
`http` 请求，如果有数据发生变更则响应变更的数据信息，如果超过 `60s` 仍然没有数据变更则响应空数据，网关层接到响应后，继续发起 `http`
请求，反复同样的请求。
+
+### 3.3 流程分析
+
+流程分析是从源码的角度，展示服务注册流程，数据同步流程和服务调用流程。
+
+#### 3.3.1 服务注册流程
+
+- 读取dubbo服务
+
+使用注解`@ShenyuDubboClient`标记需要注册到网关的`dubbo`服务。
+
+注解扫描通过`ApacheDubboServiceBeanListener`完成，它实现了`ApplicationListener<ContextRefreshedEvent>`接口，在`Spring`容器启动过程中，发生上下文刷新事件时，开始执行事件处理方法`onApplicationEvent()`。在重写的方法逻辑中，读取`Dubbo`服务`ServiceBean`，构建元数据对象和`URI`对象，并向`shenyu-admin`注册。
+
+具体的注册逻辑由注册中心实现，请参考
[客户端接入原理](https://shenyu.apache.org/zh/docs/design/register-center-design/) 。
+
+
+- 处理注册信息
+
+客户端通过注册中心注册的元数据和`URI`数据，在`shenyu-admin`端进行处理，负责存储到数据库和同步给`shenyu`网关。`Dubbo`插件的客户端注册处理逻辑在`ShenyuClientRegisterDubboServiceImpl`中。继承关系如下：
+
+
+
+- ShenyuClientRegisterService：客户端注册服务，顶层接口；
+- FallbackShenyuClientRegisterService：注册失败，提供重试操作；
+- AbstractShenyuClientRegisterServiceImpl：抽象类，实现部分公共注册逻辑；
+- ShenyuClientRegisterDubboServiceImpl：实现`Dubbo`插件的注册；
+
+注册信息包括选择器，规则和元数据。
+
+
+整体的`dubbo`服务注册流程如下：
+
+
+
+#### 3.3.2 数据同步流程
+
+- admin更新数据
+
+假设在在后台管理系统中，新增一条选择器数据，请求会进入`SelectorController`类中的`createSelector()`方法，它负责数据的校验，添加或更新数据，返回结果信息。
+
+在`SelectorServiceImpl`类中通过`createOrUpdate()`方法完成数据的转换，保存到数据库，发布事件，更新`upstream`。
+
+在`Service`类完成数据的持久化操作，即保存数据到数据库。发布变更数据通过`eventPublisher.publishEvent()`完成，这个`eventPublisher`对象是一个`ApplicationEventPublisher`类，这个类的全限定名是`org.springframework.context.ApplicationEventPublisher`，发布数据的功能正是是通过`Spring`相关的功能来完成的。
+
+当事件发布完成后，会自动进入到`DataChangedEventDispatcher`类中的`onApplicationEvent()`方法，根据不同数据类型和数据同步方式进行事件处理。
+
+- 网关数据同步
+
+网关在启动时，根据指定的数据同步方式加载不同的配置类，初始化数据同步相关类。
+
+在接收到数据后，进行反序列化操作，读取数据类型和操作类型。不同的数据类型，有不同的数据处理方式，所以有不同的实现类。但是它们之间也有相同的处理逻辑，所以可以通过模板方法设计模式来实现。相同的逻辑放在抽象类`AbstractDataHandler`中的`handle()`方法中，不同逻辑就交给各自的实现类。
+
+新增一条选择器数据，是新增操作，会进入到`SelectorDataHandler.doUpdate()`具体的数据处理逻辑中。
+
+在通用插件数据订阅者`CommonPluginDataSubscriber`，负责处理所有插件、选择器和规则信息
+
+将数据保存到网关的内存中，`BaseDataCache`是最终缓存数据的类，通过单例模式实现。选择器数据就存到了`SELECTOR_MAP`这个`Map`中。在后续使用的时候，也是从这里拿数据。
+
+上述逻辑用流程图表示如下：
+
+
+
+#### 3.3.3 服务调用流程
+
+在`Dubbo`插件体系中，类继承关系如下：
+
+
+
+> ShenyuPlugin：顶层接口，定义接口方法；
+>
+> AbstractShenyuPlugin：抽象类，实现插件共有逻辑；
+>
+>
AbstractDubboPlugin：dubbo插件抽象类，实现`dubbo`共有逻辑（ShenYu网关支持ApacheDubbo和AlibabaDubbo）；
+>
+> ApacheDubboPlugin：ApacheDubbo插件。
+
+
+-
org.apache.shenyu.web.handler.ShenyuWebHandler.DefaultShenyuPluginChain#execute()
+
+通过`ShenYu`网关代理后，请求入口是`ShenyuWebHandler`，它实现了`org.springframework.web.server.WebHandler`接口，通过责任链设计模式将所有插件连接起来。
+
+- org.apache.shenyu.plugin.base.AbstractShenyuPlugin#execute()
+
+当请求到网关时，判断某个插件是否执行，是通过指定的匹配逻辑来完成。在`execute()`方法中执行选择器和规则的匹配逻辑。
+
+
+- org.apache.shenyu.plugin.global.GlobalPlugin#execute()
+
+最先被执行的是`GlobalPlugin` ，它是一个全局插件，在`execute()`方法中构建上下文信息。
+
+- org.apache.shenyu.plugin.base.RpcParamTransformPlugin#execute()
+
+接着被执行的是`RpcParamTransformPlugin` ，
它负责从`http`请求中读取参数，保存到`exchange`中，传递给`rpc`服务。在`execute()`方法中，执行该插件的核心逻辑：从`exchange`中获取请求信息，根据请求传入的内容形式处理参数。
+
+- org.apache.shenyu.plugin.dubbo.common.AbstractDubboPlugin
+
+然后被执行的是`DubboPlugin`
。在`doExecute()`方法中，主要是检查元数据和参数。在`doDubboInvoker()`方法中设置特殊的上下文信息，然后开始`dubbo`的泛化调用。
+
+在`genericInvoker()`方法中：
+
+- 获取`ReferenceConfig`对象；
+- 获取泛化服务`GenericService`对象；
+- 构造请求参数`pair`对象；
+- 发起异步的泛化调用。
+
+通过泛化调用就可以实现在网关调用`dubbo`服务了。
+
+`ReferenceConfig`对象是支持泛化调用的关键对象 ，它的初始化操作是在数据同步的时候完成的。
+
+- org.apache.shenyu.plugin.response.ResponsePlugin#execute()
+
+最后被执行的是`ResponsePlugin` ，它统一处理网关的响应结果信息。处理类型由`MessageWriter`决定，类继承关系如下：
+
+
+
+> MessageWriter：接口，定义消息处理方法；
+>
+> NettyClientMessageWriter：处理`Netty`调用结果；
+>
+> RPCMessageWriter：处理`RPC`调用结果；
+>
+> WebClientMessageWriter：处理`WebClient`调用结果；
+
+`Dubbo`服务调用，处理结果是`RPCMessageWriter`。
+
+- org.apache.shenyu.plugin.response.strategy.RPCMessageWriter#writeWith()
+
+在`writeWith()`方法中处理响应结果，获取结果或处理异常。
+
+分析至此，关于`Dubbo`插件的源码分析就完成了，分析流程图如下：
+
+
+
+
+## 4. 小结
+
+本文从实际案例出发，由浅入深分析了`ShenYu`网关对Dubbo服务的代理过程。涉及到的主要知识点如下：
+
+- 通过责任链设计模式执行插件；
+- 使用模板方法设计模式实现`AbstractShenyuPlugin`，处理通用的操作类型；
+- 使用单例设计模式实现缓存数据类`BaseDataCache`；
+- 通过`springboot starter`即可引入不同的注册中心和数同步方式，扩展性很好；
+- 通过`admin`支持规则热更新，方便流量管控；
+- `Disruptor`队列是为了数据与操作解耦，以及数据缓冲。
diff --git a/static/imgs/blog/shenyu-dubbo/ApacheDubboPlugin.png
b/static/imgs/blog/shenyu-dubbo/ApacheDubboPlugin.png
new file mode 100644
index 0000000000..690d5277e4
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/ApacheDubboPlugin.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-en.png
b/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-en.png
new file mode 100644
index 0000000000..a3de777f16
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-en.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-zh.png
b/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-zh.png
new file mode 100644
index 0000000000..d2db4833fa
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/ApacheShenYu-Dubbo-zh.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/MessageWriter.png
b/static/imgs/blog/shenyu-dubbo/MessageWriter.png
new file mode 100644
index 0000000000..05eb76ea8e
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/MessageWriter.png
differ
diff --git
a/static/imgs/blog/shenyu-dubbo/ShenyuClientRegisterDubboServiceImpl.png
b/static/imgs/blog/shenyu-dubbo/ShenyuClientRegisterDubboServiceImpl.png
new file mode 100644
index 0000000000..fac15d4fbb
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/ShenyuClientRegisterDubboServiceImpl.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/data-sync-seq-en.png
b/static/imgs/blog/shenyu-dubbo/data-sync-seq-en.png
new file mode 100644
index 0000000000..b152e21893
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/data-sync-seq-en.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/data-sync-seq-zh.png
b/static/imgs/blog/shenyu-dubbo/data-sync-seq-zh.png
new file mode 100644
index 0000000000..41232a5b12
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/data-sync-seq-zh.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/data-sync.png
b/static/imgs/blog/shenyu-dubbo/data-sync.png
new file mode 100644
index 0000000000..99ce37bf2d
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/data-sync.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-enable-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-enable-en.png
new file mode 100644
index 0000000000..b9375bc748
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-enable-en.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-enable-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-enable-zh.png
new file mode 100644
index 0000000000..1c099883f9
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-enable-zh.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-execute-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-execute-en.png
new file mode 100644
index 0000000000..1169f344b7
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-execute-en.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-execute-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-execute-zh.png
new file mode 100644
index 0000000000..af74461bd0
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-execute-zh.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-register-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-register-en.png
new file mode 100644
index 0000000000..aada1f8f52
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-register-en.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-register-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-register-zh.png
new file mode 100644
index 0000000000..d90019b11d
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-register-zh.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-rule-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-rule-en.png
new file mode 100644
index 0000000000..8022356861
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-rule-en.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-rule-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-rule-zh.png
new file mode 100644
index 0000000000..43ebfb5428
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/dubbo-rule-zh.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-selector-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-selector-en.png
new file mode 100644
index 0000000000..895692a17e
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-selector-en.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-selector-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-selector-zh.png
new file mode 100644
index 0000000000..5abe3d3ad6
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-selector-zh.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-service-list-en.png
b/static/imgs/blog/shenyu-dubbo/dubbo-service-list-en.png
new file mode 100644
index 0000000000..c1272330a2
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-service-list-en.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/dubbo-service-list-zh.png
b/static/imgs/blog/shenyu-dubbo/dubbo-service-list-zh.png
new file mode 100644
index 0000000000..00f8298cdb
Binary files /dev/null and
b/static/imgs/blog/shenyu-dubbo/dubbo-service-list-zh.png differ
diff --git a/static/imgs/blog/shenyu-dubbo/register-client.png
b/static/imgs/blog/shenyu-dubbo/register-client.png
new file mode 100644
index 0000000000..14fee2e397
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/register-client.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/register-server.png
b/static/imgs/blog/shenyu-dubbo/register-server.png
new file mode 100644
index 0000000000..b907b803e5
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/register-server.png
differ
diff --git a/static/imgs/blog/shenyu-dubbo/shenyu.png
b/static/imgs/blog/shenyu-dubbo/shenyu.png
new file mode 100644
index 0000000000..06c38d78a8
Binary files /dev/null and b/static/imgs/blog/shenyu-dubbo/shenyu.png differ
