General development dir translation and include img (#47)
* update general-development/file-download.md
* update general-development/file-upload.md
* update ../general-development/http-filter.md
* add images dir ../assets/images/
* update ../general-development/local-develop-test.md
* java-chassis-reference/en_US/general-development/AlarmEvent.md
* update java-chassis-reference/en_US/general-development/CORS.md
* update java-chassis-reference/en_US/general-development/context.md
* update java-chassis-reference/en_US/general-development/cross-app-invocation.md
* update java-chassis-reference/en_US/general-development/dai-li-she-zhi.md
* java-chassis-reference/en_US/general-development/dnsconfig.md
* java-chassis-reference/en_US/general-development/produceprocess.md
* java-chassis-reference/en_US/general-development/reactive.md
* update java-chassis-reference/en_US/general-development/report-framework-version.md
* java-chassis-reference/en_US/general-development/secret-field.md
* java-chassis-reference/zh_CN/general-development/dai-li-she-zhi.md
* java-chassis-reference/zh_CN/general-development/dnsconfig.md
* fix java-chassis-reference/en_US/general-development/AlarmEvent.md issue
* fix java-chassis-reference/en_US/general-development/context.md issue
* fix java-chassis-reference/zh_CN/general-development/cross-app-invocation.md issue
* fix java-chassis-reference/en_US/general-development/dai-li-she-zhi.md issue
* fix java-chassis-reference/zh_CN/general-development/dnsconfig.md issue
* fix java-chassis-reference/zh_CN/general-development/file-download.md issue
* fix java-chassis-reference/en_US/general-development/file-upload.md issue
* fix java-chassis-reference/en_US/general-development/http-filter.md issue
* fix java-chassis-reference/en_US/general-development/local-develop-test.md issue
* fix java-chassis-reference/en_US/general-development/reactive.md issue
* fix secen desc -> secenario issue
* Polish the sencenses of CORS.
* Update the title of context
* Update context.md
* Update dnsconfig.md
* Update reactive.md
diff --git a/java-chassis-reference/en_US/general-development/AlarmEvent.md b/java-chassis-reference/en_US/general-development/AlarmEvent.md
index 538bcd5..6b3260d 100644
--- a/java-chassis-reference/en_US/general-development/AlarmEvent.md
+++ b/java-chassis-reference/en_US/general-development/AlarmEvent.md
@@ -1,11 +1,11 @@
-# 获取熔断与实例隔离告警事件
+# Get warning event from Circuit Breaker or Instance Isolation.
-## 场景描述
-* 在微服务运行期间熔断或实例隔离状态发生变化时，需要监听到相关事件，获取相关信息并进行处理
+## Senario
+* When the microservice is running, Circuit Breaker or the instance isolation status changes, you need to listen to related events, get relevant information and handle it.
-## 使用参考
+## Use Reference
-* 监听熔断事件
+* Monitor CircuitBreaker events
```
Object receiveEvent = new Object() {
@Subscribe
@@ -15,7 +15,7 @@
};
circutBreakerEventNotifier.eventBus.register(receiveEvent);
```
-* 监听实例隔离事件
+* Listen for instance isolation events
```
Object receiveEvent = new Object() {
@Subscribe
@@ -25,7 +25,7 @@
};
circutBreakerEventNotifier.eventBus.register(receiveEvent);
```
-* 两个事件均监听
+* Both events are monitored
```
Object receiveEvent = new Object() {
@Subscribe
diff --git a/java-chassis-reference/en_US/general-development/CORS.md b/java-chassis-reference/en_US/general-development/CORS.md
index be16cff..b60b167 100644
--- a/java-chassis-reference/en_US/general-development/CORS.md
+++ b/java-chassis-reference/en_US/general-development/CORS.md
@@ -1,29 +1,29 @@
-# CORS机制
+# CORS mechanism
-## 概念阐述
+## Concept Description
-跨域资源共享(CORS, Cross-Origin Resource Sharing)允许Web服务器进行跨域访问控制，使浏览器可以更安全地进行跨域数据传输。
+Cross-Origin Resource Sharing (CORS) allows Web servers to perform cross-domain access, enabling browsers to more securely transfer data across domains.
-## 场景描述
+## Scenario
-当用户需要从浏览器上跨域发送REST请求时就有可能要用到CORS机制，接收跨域请求的微服务需要开启CORS支持。
+When the user needs to send REST requests across the origin webserver, the CORS mechanism may be used. The microservices that receive cross-domain requests need to enable CORS support.
-## 配置说明
+## Configuration instructions
-CORS功能在microservice.yaml文件中配置，配置项见下表所述。
+The CORS function is configured in the microservice.yaml file. The configuration items are described in the following table.
-| 配置项 | 默认值 | 取值范围 | 是否必选 | 含义 | 注意 |
+| Configuration Item | Default Value | Range of Value | Required | Meaning |
| :--- | :--- | :--- | :--- | :--- | :--- |
-| servicecomb.cors.enabled | `false` | `true`/`false` | 否 | 是否开启CORS功能 | - |
-| servicecomb.cors.origin | `*` | - | 否 | Access-Control-Allow-Origin | - |
-| servicecomb.cors.allowCredentials | `false` | `true`/`false` | 否 | Access-Control-Allow-Credentials | 根据CORS标准，当Access-Control-Allow-Credentials设置为`true`时，Access-Control-Allow-Origin不可设置为"*"，否则将会抛出异常 |
-| servicecomb.cors.allowedHeader | 无 | - | 否 | Access-Control-Allow-Headers | 多个值使用逗号分隔 |
-| servicecomb.cors.allowedMethod | 无 | - | 否 | Access-Control-Allow-Methods | 多个值使用逗号分隔 |
-| servicecomb.cors.exposedHeader | 无 | - | 否 | Access-Control-Expose-Headers | 多个值使用逗号分隔 |
-| servicecomb.cors.maxAge | 无 | (0,2147483647]，整型 | 否 | Access-Control-Max-Age | 单位是秒，如果用户不配置此项，则CORS应答中没有Access-Control-Max-Age |
+| servicecomb.cors.enabled | `false` | `true`/`false` | No | Whether to enable CORS function | - |
+| servicecomb.cors.origin | `*` | - | No | Access-Control-Allow-Origin | - |
+| servicecomb.cors.allowCredentials | `false` | `true`/`false` | No | Access-Control-Allow-Credentials | According to the CORS standard, when Access-Control-Allow-Credentials is set to `true`, Access- Control-Allow-Origin cannot be set to "*", otherwise an exception will be thrown |
+| servicecomb.cors.allowedHeader | None | - | No | Access-Control-Allow-Headers | Multiple values separated by commas |
+| servicecomb.cors.allowedMethod | None | - | No | Access-Control-Allow-Methods | Multiple values separated by commas |
+| servicecomb.cors.exposedHeader | None | - | No | Access-Control-Expose-Headers | Multiple values separated by commas |
+| servicecomb.cors.maxAge | None | (0,2147483647], Integer | No | Access-Control-Max-Age | The unit is seconds. If the user does not configure this, there is no Access-Control-Max in the CORS response. Age |
-## 示例代码
+## Sample Code
```yaml
servicecomb:
diff --git a/java-chassis-reference/en_US/general-development/context.md b/java-chassis-reference/en_US/general-development/context.md
index 1b4b97a..5b77be8 100644
--- a/java-chassis-reference/en_US/general-development/context.md
+++ b/java-chassis-reference/en_US/general-development/context.md
@@ -1,31 +1,31 @@
-# 使用Context传递控制消息
+# Delivery Messages through Context
-ServiceComb提供了Context在微服务之间传递数据。Context是key/value对，只能够使用String类型的数据。由于Context会序列化为json格式并通过HTTP Header传递，因此也不支持ASCII之外的字符，其他字符需要开发者先自行编码再传递。Context在一次请求中，会在请求链上传递，不需要重新设置。[access log](../build-provider/access-log-configuration.md)的trace id等功能都基于这个特性实现的。
+ServiceComb provides a Context to delivery data between microservices. Context is a key/value pair and can only use data of type String. Since the Context is serialized into the Json format and passed through the HTTP header, characters other than ASCII are not supported. Other characters require the developer to encode and pass the code. The Context is passed on the request chain in a single request and does not need to be reset. The functions such as trace id of [access log](../build-provider/access-log-configuration.md) are implemented based on this feature.
-## 场景描述
-* 在认证场景，Edge Service认证通过以后，需要将会话ID、用户名称等信息传递给微服务，实现鉴权等逻辑
-* 灰度发布场景，需要结合自定义的tag实现引流，tag信息需要传递给微服务
+## Scenario
+* In the authentication scenario, after the Edge Service authentication is passed, the session ID, username, and other information need to be passed to the microservice to implement authentication and other logic.
+* Grayscale publishing scenarios, need to be combined with custom tags shunt request, tag information needs to be passed to the microservices
-## 使用参考
+## Use Reference
-* 在Hanlder中获取和设置Context
+* Get and set the Context in Handler
-Handler包含了Invocation对象，可以直接调用invocation.addContext和invocation.getContext设置。
+The Handler contains the Invocation object, which can be called directly in the invocation.addContext and invocation.getContext settings.
-* 在服务接口中获取Context
+* Get Context in the service interface
-通过接口注入
+Inject through the interface
```
public Response cseResponse(InvocationContext c1)
```
-或者
+or
```
ContextUtils.getInvocationContext()
```
-* 在Edge Service中设置Context
+* Set the Context in the Edge Service
-通过重载EdgeInvocation
+By override EdgeInvocation
```
EdgeInvocation edgeInvocation = new EdgeInvocation() {
protected void createInvocation() {
@@ -33,4 +33,4 @@
this.invocation.addContext("hello", "world");
}
};
-```
\ No newline at end of file
+```
diff --git a/java-chassis-reference/en_US/general-development/cross-app-invocation.md b/java-chassis-reference/en_US/general-development/cross-app-invocation.md
index 097e542..cf3e576 100644
--- a/java-chassis-reference/en_US/general-development/cross-app-invocation.md
+++ b/java-chassis-reference/en_US/general-development/cross-app-invocation.md
@@ -1,30 +1,31 @@
-### 概念阐述
+# Cross App Invocation
+### Concept Description
-应用是微服务实例隔离层次中的一层，一个应用包含多个微服务。默认情况下，只允许同应用的微服务实例相互调用。
+An application is a layer in the microservice instance isolation hierarchy, and an application contains multiple microservices. By default, only microservice instances of the same application are allowed to call each other.
-### 场景描述
+### Scenario
-当用户需要不同应用间的微服务相互调用时，就需要开启跨应用调用功能。
+When a user needs micro-services between different applications to call each other, it is necessary to enable the cross-application calling function.
-### 配置说明
+### Configuration instructions
-若要开启跨应用调用，首先需在provider端的microservice.yaml文件开启跨应用调用配置。配置项如下：
+To enable cross-application calls, you first need to enable cross-application call configuration in the microservice.yaml file on the provider side. The configuration items are as follows:
```yaml
service_description:
# other configuration omitted
properties:
- allowCrossApp: true # enable cross app invocation
+ allowCrossApp: true # enable cross-app invocation
```
-consumer端指定微服务名称调用provider的时候，需要加上provider所属的应用ID，格式变为`[appID]:[microserviceName]`。
+When the consumer client specifies the microservice name to call the provider, it needs to add the application ID to which the provider belongs, and the format becomes `[appID]:[microserviceName]`.
-### 示例代码
+### Sample Code
-示例假设provider所属应用为helloApp，微服务名称为helloProvider；consumer所属应用为helloApp2，微服务名称为helloConsumer。
+The example assumes that the application to which the provider belongs is helloApp, the name of the microservice is helloProvider, the application to which the consumer belongs is helloApp2, and the name of the microservice is helloConsumer.
-- RestTemplate调用方式
+- RestTemplate invocation mode
- 当consumer端以RestTemplate方式开发微服务消费者时，需要在调用的URL中将`[microserviceName]`改为`[appID]:[microserviceName]`，代码示例如下：
+ When the consumer client develops the microservice consumer in the RestTemplate mode, you need to change `[microserviceName]` to `[appID]:[microserviceName]` in the called URL. The code example is as follows:
```java
RestTemplate restTemplate = RestTemplateBuilder.create();
@@ -32,15 +33,14 @@
.getForEntity("cse://helloApp:helloProvider/hello/sayHello?name={name}",
String.class, "ServiceComb");
```
-
-- RPC调用方式
-
- 当consumer端以RPC方式开发微服务消费者时，声明的服务提供者代理如下：
+- RPC invocation mode
+ When the consumer client develops a microservice consumer in RPC mode, the declared service provider proxy is as follows:
```java
@RpcReference(schemaId = "hello", microserviceName = "helloApp:helloProvider")
private Hello hello;
```
- 调用方式和调用同应用下的微服务相同：
+ Cross-application invocation is the same way as invocate microservices under the same application:
+
```java
hello.sayHello("ServiceComb");
```
diff --git a/java-chassis-reference/en_US/general-development/dai-li-she-zhi.md b/java-chassis-reference/en_US/general-development/dai-li-she-zhi.md
index cbbc1f1..3ff8458 100644
--- a/java-chassis-reference/en_US/general-development/dai-li-she-zhi.md
+++ b/java-chassis-reference/en_US/general-development/dai-li-she-zhi.md
@@ -1,32 +1,29 @@
-## 背景
+## background
-作为一名开发者，在公司开发环境，可能是通过公司代理网络接入到因特网。如果调试服务时还必须依赖网上资源，比如直接连接华为共有云服务中心，那么就必须配置代理。
+As a developer, in a company development environment, it is possible to access the Internet through a corporate agent network. If debugging services depends on online resources, such as directly connecting to public cloud service center, you must configure the agent.
-配置方式，在microservice.yaml文件增加proxy配置：
+Configuration mode, add proxy configuration in microservice.yaml file:
```yaml
servicecomb:
- proxy:
- enable: true #是否开启代理
- host: yourproxyaddress #代理地址
- port: 80 #代理端口
- username: yourname #用户名
- passwd: yourpassword #密码
+ proxy:
+ enable: true #Do you want to enable the proxy?
+ host: yourproxyaddress #proxy address
+ port: 80 #proxy port
+ username: yourname #username
+ passwd: yourpassword #password
```
-**注意：当前仅支持连接服务中心、配置中心、服务看板支持代理，如果对接其他三方服务，可以读取这个配置，自行配置代理，vertx httpclient支持代理设置，例如：**
+**Note: Currently only supports connection service center, configuration center support agent. If you connect other three-party services, you can read this configuration, configure the agent yourself, vertx httpclient supports proxy settings, for example: **
```java
- HttpClientOptions httpClientOptions = new HttpClientOptions();
- if (isProxyEnable()) {
- ProxyOptions proxy = new ProxyOptions();
- proxy.setHost("host");
- proxy.setPort(port);
- proxy.setUsername("username");
- proxy.setPassword("passwd");
- httpClientOptions.setProxyOptions(proxy);
- }
+ HttpClientOptions httpClientOptions = new HttpClientOptions();
+ If (isProxyEnable()) {
+ ProxyOptions proxy = new ProxyOptions();
+ proxy.setHost("host");
+ proxy.setPort(port);
+ proxy.setUsername("username");
+ proxy.setPassword("passwd");
+ httpClientOptions.setProxyOptions(proxy);
+ }
```
-
-
-
diff --git a/java-chassis-reference/en_US/general-development/dnsconfig.md b/java-chassis-reference/en_US/general-development/dnsconfig.md
index 461d462..426de56 100644
--- a/java-chassis-reference/en_US/general-development/dnsconfig.md
+++ b/java-chassis-reference/en_US/general-development/dnsconfig.md
@@ -1,41 +1,39 @@
-## 场景描述
+## Scenario
+When a user uses a domain name to connect to a public cloud or a third-party system, you need to use the domain name resolution DNS system. The DNS used in different systems and different frameworks may be different. Therefore, it is necessary to provide a unified configuration entry so that development and operation personnel can customize the DNS resolution mechanism without being completely subject to system configuration.
-用户使用域名连接华为公有云或者三方系统时，需要使用到域名解析系统。在不同的系统、不同的框架使用的域名解析机制都可能不太一样。所以我们有必要提供一个统一的配置入口，以便开发运维人员可以自定义DNS解析机制，而不完全受制于系统配置。
+## DNS Configuration
-## DNS配置
-
-DNS配置项写在microservice.yaml文件中，支持统一制定证书，也可以添加tag进行更细粒度的配置，有tag的配置会覆盖全局配置，配置格式如下：
+The DNS configuration item is written in the microservice.yaml file. It supports the unified development of certificates. It can also add tags for more fine-grained configuration. The tag configuration overrides the global configuration. The configuration format is as follows:
```
addressResolver.[tag].[property]
```
-常见的tag如下表：
+The common tags are as follows:
-| 项目 | tag |
+| Project | tag |
| :--- | :--- |
-| 服务中心 | sc.consumer |
-| 配置中心 | cc.consumer |
-| 看板中心 | mc.consumer |
-| 用户自定义 | self.tag |
+| Service Center | sc.consumer |
+| Configuration Center | cc.consumer |
+| User Defined | self.tag |
-各个properties详细说明（设置Vertx DNS解析）
+The detailed description of each property (Set Vertx DNS resolution)
``` yaml
addressResolver:
- servers: 8.8.8.8,8.8.4.4 #对应Linux /etc/resolv.conf的nameserver,DNS服务器地址，支持配置多个，以逗号隔开
- ndots: 1 #对应linux /etc/resolv.conf里面的options: ndots, 作用就是如果给的域名里面包含的点的个数少于该阈值，那么DNS解析的时候就会默认加上searchDomains的值，这个必须和searchDomains搭配使用，Linux默认为1，华为公有云PAAS（包含容器）默认是4
- searchDomains: a,b,c #对应linux /etc/resolv.conf里面的search，和ndots搭配使用，如果当前域名的点个数少于设置值，解析时就会把这些值添加到域名后面一起解析，比如ndots设置的为4，当前域名为servicecomb.cn-north-1.myhwclouds.com，只有三个点，那么解析的时候就会自动加上servicecomb.cn-north-1.myhwclouds.com.a去解析，没解析出来在用servicecomb.cn-north-1.myhwclouds.com.b，直到能最后解析出来
- optResourceEnabled: true #optional record is automatically included in DNS queries
- cacheMinTimeToLive: 0 #最小缓存时间
- cacheMaxTimeToLive: 10000 #最大缓存时间
- cacheNegativeTimeToLive: 0 #DNS解析失败后，下次重试的等待时间
- queryTimeout: 5000 #查询超时时间
- maxQueries: 4 #查询次数
- rdFlag: true #设置DNS递归查询
- rotateServers: true #设置是否支持轮询
+ servers: 8.8.8.8, 8.8.4.4 #corresponds to the nameserver of Linux /etc/resolv.conf, the DNS server address, supports multiple configurations, separated by commas
+ ndots: 1 # corresponds to the options in linux /etc/resolv.conf: ndots, the role is that if the number of points contained in the domain name is less than the threshold, then DNS resolution will be added by default to the value of searchDomains. This must be used in conjunction with searchDomains.
+ searchDomains: a, b, c # Corresponding to the search in linux /etc/resolv.conf, and ndots, if the number of points in the current domain name is less than the set value, these values will be added to the domain name and parsed together when parsing, for example, the ndots is set to 4. The current domain name is servicecomb.cn-north-1.myhwclouds.com, only three points. Then the servicecomb.cn-north-1.myhwclouds.com.a will be automatically parsed when parsing, not parsed out. Servicecomb.cn-north-1.myhwclouds.com.b until it can be finally parsed
+ optResourceEnabled: true #optional record is automatically included in DNS queries
+ cacheMinTimeToLive: 0 #minimum cache time
+ cacheMaxTimeToLive: 10000 #Maximum cache time
+ cacheNegativeTimeToLive: 0 #DNS resolving failure time after the next retry
+ queryTimeout: 5000 #Query timeout
+ maxQueries: 4 #Query times
+ rdFlag: true #Set DNS recursive query
+ rotateServers: true #Set whether to support polling
```
-## 示例
+##example
```java
VertxOptions vertxOptions = new VertxOptions();
@@ -45,6 +43,6 @@
HttpClientOptions httpClientOptions = createHttpClientOptions();
ClientPoolManager<HttpClientWithContext> clientMgr = new ClientPoolManager<>(vertx, new HttpClientPoolFactory(httpClientOptions));
clientMgr.findThreadBindClientPool().runOnContext(httpClient -> {
- // do some http request
+ // do some http request
});
```
diff --git a/java-chassis-reference/en_US/general-development/file-download.md b/java-chassis-reference/en_US/general-development/file-download.md
index d6d274b..56ede96 100644
--- a/java-chassis-reference/en_US/general-development/file-download.md
+++ b/java-chassis-reference/en_US/general-development/file-download.md
@@ -57,10 +57,9 @@
## 4.Download InputStream
-Because InputStream does not necessarily mean file downloading, it needs to be identified by swagger annotation (@ApiResponse). This is a file download scenario.
+Because InputStream does not mean file downloading for sure, it needs to be annotated by 'swagger annotation' (@ApiResponse). This is a file download scenario.
-In some scenarios, resources are not stored locally, such as in OBS cloud services, and OBS resources are output in InputStream mode.
-
+In some scenarios, resources are not stored locally.
```
return ResponseEntity
.ok()
@@ -79,7 +78,7 @@
If this does not meet the requirements, assuming the file suffix is, and the expected file type is application/file-xyz, any of the following methods can be resolved:
-### 1)Expanding through Java's mime type mechanism
+### 1) Extend via Java's mime type mechanism
In the META-INF directory, create a mime. Types file with the contents:
@@ -149,7 +148,7 @@
note:
-* When the ReadStreamPart instance is obtained, the file content is not downloaded. The save series method is called to start reading the file data from the network.
+* When the ReadStreamPart instance is obtained, the file content is not downloaded. The save or other methods is called to start reading the file data from the network.
* If you use saveAsBytes, saveAsString, the data is directly stored in the memory; if the downloaded file is large, there will be a risk of memory explosion.
diff --git a/java-chassis-reference/en_US/general-development/file-upload.md b/java-chassis-reference/en_US/general-development/file-upload.md
index 8eeacb0..861af03 100644
--- a/java-chassis-reference/en_US/general-development/file-upload.md
+++ b/java-chassis-reference/en_US/general-development/file-upload.md
@@ -14,7 +14,7 @@
* Supports servlet-defined javax.servlet.http.Part type, also supports org.springframework.web.multipart.MultipartFile type
-* The two datatype functions are consistent, and the underlying part of MultipartFile is also Part
+* The two datatype functions are consistent, and MultipartFile is also base on Part type
* Two data types can be mixed, for example, the first parameter is Part and the second parameter is MultipartFile
diff --git a/java-chassis-reference/en_US/general-development/http-filter.md b/java-chassis-reference/en_US/general-development/http-filter.md
index 28fae3f..5ce0dd1 100644
--- a/java-chassis-reference/en_US/general-development/http-filter.md
+++ b/java-chassis-reference/en_US/general-development/http-filter.md
@@ -16,7 +16,7 @@
* If getOrder returns the same value, the corresponding instance order is randomly determined
-Whether it is request or response, read the body stream, use getBodyBytes\ (\), the return value may be null (such as the scene called get), if not null, the corresponding stream length, Obtain through getBodyBytesLength\ (\ ).
+Whether it is request or response, read the body stream, use getBodyBytes\ (\), the return value may be null (such as scenario of getting an invocation), if not null, the corresponding stream length, Obtain through getBodyBytesLength\ (\ ).
# 2.HttpClientFilter
@@ -87,10 +87,10 @@
## 3.3 afterReceiveRequest
-After receiving the request, the signature is calculated according to the URL, header, query, and code stream, and compared with the signature in the header. If the signature is incorrect, a Response is directly constructed as the return value. As long as the NULL is not returned, the framework will interrupt the other HttpClientFilter. Call.
+After receiving the request, the signature is calculated according to the URL, header, query, and code stream, and compared with the signature in the header. If the signature is incorrect, a Response is directly constructed as the return value. As long as the NULL is not returned, the framework will interrupt the other HttpClientFilter Call.
## 3.4 beforeSendResponse
Before sending a response, the signature is calculated according to the header and the stream and set to the header.
-Because the invocation has not yet been constructed, the call flow has gone wrong, so the invocation may be null.<Paste>
+Because the invocation has not yet been constructed, the call flow has gone wrong, so the invocation may be null.
diff --git a/java-chassis-reference/en_US/general-development/local-develop-test.md b/java-chassis-reference/en_US/general-development/local-develop-test.md
index c66349b..c0346b9 100644
--- a/java-chassis-reference/en_US/general-development/local-develop-test.md
+++ b/java-chassis-reference/en_US/general-development/local-develop-test.md
@@ -9,7 +9,7 @@
### Local debugging by setting up environmental information
-Service center is an important component in the microservice architecture, and is used for managing, registering, and detecting metadata and instance metadata. The logic relationship between the service center and microservice provider/consumer is as follows:
+The Service Center is an important component in the microservice architecture, this is used in managing and handle: registering and discovering, for service metadata and service instance metadata. The logic relationship between the service center and microservice provider/consumer is as follows:
## Starting Local ServiceCenter
diff --git a/java-chassis-reference/en_US/general-development/produceprocess.md b/java-chassis-reference/en_US/general-development/produceprocess.md
index 6e204f0..f64077d 100644
--- a/java-chassis-reference/en_US/general-development/produceprocess.md
+++ b/java-chassis-reference/en_US/general-development/produceprocess.md
@@ -1,23 +1,23 @@
-# 返回值序列化扩展
-## 概念阐述
+# return value serialization extension
+## Concept Description
-当前REST通道返回值支持application/json和text/plain两种格式，支持开发人员扩展和重写，服务提供者通过produces声明可提供序列化能力，服务消费者通过请求的Accept头指明返回值序列化方式，默认返回application/json格式的数据。
+The current REST channel return value supports both application/json and text/plain formats, supports developer extensions and rewrites, service providers provide serialization capabilities through producer declarations, and service consumers specify return value serialization through the request's Accept header. By default, the data in application/json format is returned.
-## 开发说明
+## Development Instructions
-* ### 扩展
+* ### extension
- 开发人员可以根据业务需要，通过编程的方式来扩展返回值序列化方式。实施步骤如下，以扩展支持application/xml格式为例：
+ Developers can extend the return value serialization method programmatically based on business needs. The implementation steps are as follows, taking the extended support application/xml format as an example:
- 1.实现接口`ProduceProcessor`
+ 1. Implement the interface `ProduceProcessor`.
- > getName\(\)返回当前扩展的数据类型名
- >
- > getOrder\(\)返回当前数据类型优先级，有多个同名实现类时生效，只加载优先级最高的，数字越小优先级越高
- >
- > doEncodeResponse\(OutputStream output, Object result\)把result对象编码成output，此处逻辑需要自行实现
- >
- > doDecodeResponse\(InputStream input, JavaType type\)把input解析成相应对象，此处逻辑需要自行实现
+ > getName\(\) returns the current extended data type name
+ >
+ > getOrder\(\) returns the current data type priority. It has multiple implementation classes with the same name. It only loads the highest priority. The smaller the number, the higher the priority.
+ >
+ > doEncodeResponse\(OutputStream output, Object result\) encodes the result object into output, where the logic needs to be implemented by itself.
+ >
+ > doDecodeResponse\(InputStream input, JavaType type\) parses the input into the corresponding object, where the logic needs to be implemented by itself.
```java
public class ProduceAppXmlProcessor implements ProduceProcessor {
@@ -44,25 +44,25 @@
}
```
- 2.添加配置文件
+ 2. Add a configuration file
- 在resources下META-INF/services/文件夹新建文件xxx.ProduceProcessor（xxx为接口的包名），内容填写xxx.ProduceAppXmlProcessor（xxx为实现类的包名）。
+ In the META-INF/services/ folder under resources, create a new file xxx.ProduceProcessor (xxx is the package name of the interface), and fill in the content xxx.ProduceAppXmlProcessor (xxx is the package name of the implementation class).
-* ### 重写
+* ### Rewrite
- 开发人员可以对现有的application/json和text/plain两种格式实现逻辑进行重写，也可以对自行扩展的格式进行重写，以重写xml序列化方式为例：
+ Developers can rewrite the existing application/json and text/plain implementation logic, or rewrite the self-extended format to rewrite the xml serialization method as an example:
- 1.创建一个同名类`ProduceAppXmlProcessor`，实现接口`ProduceProcessor`
+ 1. Create a class named 'ProduceAppXmlProcessor` with the same name to implement the interface `ProduceProcessor`.
- 2.重写`doEncodeResponse`和`doDecodeResponse`方法里的编解码逻辑
+ 2. Rewrite the codec logic in the `doEncodeResponse` and `doDecodeResponse` methods
- 3.更改getOrder方法里的返回值，要比原方法的返回值小，例如返回-1，application/json和text/plain的原方法返回值默认都为0
+ 3. Change the return value in the getOrder method, which is smaller than the return value of the original method. For example, return -1, the original method return value of application/json and text/plain defaults to 0.
- 4.在resources下META-INF/services/文件夹新建文件xxx.ProduceProcessor（xxx为接口的包名），内容填写xxx.ProduceAppXmlProcessor（xxx为实现类的包名）。
+ 4. In the META-INF/services/ folder under resources, create a new file xxx.ProduceProcessor (xxx is the package name of the interface), and fill in the content xxx.ProduceAppXmlProcessor (xxx is the package name of the implementation class).
-* ### 验证
+* ### verification
- 服务提供者通过produces声明可提供xml序列化能力
+ Service providers provide xml serialization capabilities through producer declarations
```java
@RequestMapping(path = "/appXml", method = RequestMethod.POST, produces = MediaType.APPLICATION_XML_VALUE)
@@ -71,7 +71,7 @@
}
```
- 服务消费者通过请求的Accept头指明返回值xml序列化方式
+ The service consumer indicates the return value xml serialization mode through the request's Accept header.
```java
private void testCodeFirstAppXml(RestTemplate template, String cseUrlPrefix) {
diff --git a/java-chassis-reference/en_US/general-development/reactive.md b/java-chassis-reference/en_US/general-development/reactive.md
index dd167eb..ab917af 100644
--- a/java-chassis-reference/en_US/general-development/reactive.md
+++ b/java-chassis-reference/en_US/general-development/reactive.md
@@ -1,6 +1,6 @@
-## 简单同步模式的Producer：
+## Simple Synchronization Mode Producer:
-示例代码：
+Sample code:
```java
@GetMapping(path = "/hello/{name}")
@@ -9,19 +9,19 @@
}
```
-与此对应的处理流程如下：
+The corresponding processing flow is as follows:
-这是传统典型的工作模型，核心思想是不阻塞网络线程，将业务放在独立的线程中处理（为了简化表达，executor中只画一个线程）
+This is the traditional typical working model. The core idea is not to block network threads, and to put the business in a separate thread (to simplify the expression, only one thread is drawn in the executor)
-一般情况下，此模式问题不大。
+In general, this mode is not a big problem.
-## 嵌套同步调用：
+## Nested synchronous call:
-不是所有的业务都是简单处理一下，就可以直接应答，可能还需要调用其他微服务.
+Not all services are handled simply, you can respond directly, you may need to call other microservices.
-示例代码：
+Sample code:
```java
public interface Intf{
@@ -34,45 +34,45 @@
}
```
-与此对应的处理流程如下：
+The corresponding processing flow is as follows:
-根据这个流程的特点，可以看到会产生以下结果：
+According to the characteristics of this process, you can see the following results:
-* 因为是同步调用，在“Other microservices”未应答之前“Microservice A”的调用线程一直处于阻塞等待状态，不处理任何其他事务
+* Because it is a synchronous call, the calling thread of "Microservice A" is always in the blocking wait state before "Other microservices" is not answered, and does not process any other transactions.
-* 当Executor中所有线程都在等待远程应答时，所有新的请求都只能在Queue中排队，得不到处理，此时整个系统相当于停止工作了
+* When all threads in the Executor are waiting for a remote response, all new requests can only be queued in the Queue and cannot be processed. At this point, the entire system is equivalent to stop working.
-* 要增加处理能力，只能增加Executor中的线程数，而操作系统并不能无限地增加线程数，事实上增加线程数带来的收益是一个抛物线模型，超出一定的临界值后，系统的处理能力其实会下降，而这个临界值并不会太大
+* To increase the processing power, only increase the number of threads in the Executor, and the operating system can not increase the number of threads indefinitely. The benefit of increasing the number of threads is a parabolic model. After a specific critical value, the system handles The ability will drop, and this threshold will not be too big.
-* 当业务逻辑中，需要多次进行远程同步操作时，会更加恶化这个现象
+* When the remote synchronization operation is required multiple times in the business logic, the problem will be bigger than before.
-## 嵌套同步调用的“错误”优化：
+## "Error" optimization for nested synchronous calls:
-针对前一场景，有人会认为将“Invoke producer method”丢进另一个线程池，可以解决问题，包括以下处理方式：
+For the previous scenario, someone would think that throwing the "Invoke producer method" into another thread pool can solve the problem, including the following:
-* 在producer method打标注@Async，由AOP负责将对该方法的调用丢进其他线程池去
+* In the producer method, mark @Async, which is responsible for throwing the call to the method into other thread pools.
-* 在producer method内部通过业务代码转移线程
+* Transferring threads through business code inside the producer method
-形成以下流程：
+Form the following process:
-根据这个流程的特点，可以看到会产生以下结果：
+According to the characteristics of this process, you can see the following results:
-* “Invoke producer method”必须立即返回，否则Executor线程还是得不到释放
+* "Invoke producer method" must be returned immediately, otherwise, the Executor thread will not be released
-* “Invoke producer method”必须提供一个新的机制告知调用流程自己的返回值，不是最终返回值（当前没有这个机制）
+* "Invoke producer method" must provide a new mechanism to inform the calling process of its return value, not the final return value (currently no such mechanism)
-* 虽然Executor线程释放了，但是Customer Executor，其实还是阻塞住，在等待远端应答，整个系统的阻塞状态并没有得到改变；而且还凭空多了一次线程切换
+* Although the Executor thread is released, the Customer Executor is blocked, waiting for the remote response, the blocking state of the entire system has not changed, and there is one more thread switching.
-* 该机制看上去，唯一的作用，是释放了executor线程，让executor线程有机会处理其他请求，这相当于隔离仓的概念，处理速度慢的业务不要影响其他业务；但是这个概念serviceComb是可以直接支持的，可以配置指定的业务方法独占全新的executor，这样整个流程就跟“嵌套同步调用”完全一样，流程更简单，而不需要在“Invoke producer method”层次来做这个事情
+* The mechanism seems to have the only effect is to release the executor thread, so that the executor thread has the opportunity to process other requests, which is equivalent to the concept of quarantine, the slow processing of the business does not affect other services; but the concept of serviceComb can be directly Supported, you can configure the specified business method to monopolize the new executor, so that the whole process is the same as the "nested synchronous call", the process is simpler, and you don't need to do this at the "Invoke producer method" level.
-## 纯Reactive机制
+## Pure Reactive Mechanism
-示例代码：
+Sample code:
```java
public interface Intf{
@@ -94,45 +94,45 @@
}
```
-与此对应的处理流程如下：
+The corresponding processing flow is as follows:
-* 与传统流程不同的是，所有功能都在eventloop中执行，并不会进行线程切换
+* Unlike traditional processes, all functions are executed in the eventloop and no thread switching is performed.
-* 橙色箭头走完后，对本线程的占用即完成了，不会阻塞等待应答，该线程可以处理其他任务
+* After the orange arrow is finished, the occupation of this thread is completed, and it will not block waiting for response. The thread can handle other tasks.
-* 当收到远端应答后，由网络数据驱动开始走红色箭头的应答流程
+* After receiving the remote response, the network data drive starts to take the red arrow response process
-* 只要有任务，线程就不会停止，会一直执行任务，可以充分利用cpu资源，也不会产生多余的线程切换，去无谓地消耗cpu。
+* As long as there are tasks, the thread will not stop, the task will be executed all the time, you can make full use of the cpu resources, and will not generate redundant thread switching, to consume the CPU unnecessarily.
-因为同步模式下，需要大量的线程来提升并发度，而大量的线程又带来线程切换的额外消耗。
+Because in synchronous mode, a large number of threads are needed to increase the degree of concurrency, and a large number of threads bring additional consumption of thread switching.
-测试数据表明，reactive模式，只需要消耗同步模式不到一半的cpu，即可达到或超过同步模式的tps，并且时延更低。
+The test data shows that the reactive mode only needs to consume less than half of the CPU of the synchronous mode. And can reach or exceed the tps of the synchronous mode, and the delay is lower.
-## 混合Reactive机制
+## Hybrid Reactive Mechanism
-Reactvie要求：所有在eventloop中执行的逻辑，不允许有任何的阻塞动作，包括不限于wait、sleep、巨大循环、同步查询DB等等。
+Reactive requires that all logic executed in the eventloop does not allow any blocking actions, including not limited to wait, sleep, large loops, synchronous query DB, and so on.
-serviceComb底层是基于vertx的，vertx生态中有jdbc、mq、zooKeeper等等各种丰富组件的reactive驱动，一般情况下都可以满足要求。
+The bottom of serviceComb is based on vertx. The vertx ecosystem has reactive drivers for various rich components such as JDBC, MQ, zooKeeper, etc. Under normal circumstances, it can meet the requirements.
-但是有的场景下，确实有的同步操作无法避免，比如：
+However, in some scenarios, there are indeed some synchronization operations that cannot be avoided, such as:
-* 私有的安全加固的redis，只提供了同步驱动
+* Private security hardened redis, only provides synchronous drive
-* 较复杂的业务运算
+* More complex business operations
-* ……
+* ......
-此时，可以将这些同步的逻辑抽取出来放到线程池中去处理，而其他部分仍然使用reactive的流程。
+At this point, the logic of these synchronizations can be extracted and placed in the thread pool for processing, while other parts still use the reactive process.
-## 关于reactive的一些说明：
+## Some notes about reactive:
-* Producer：
+* Producer:
- * producer是否使用reactive与consumer如何调用，没有任何联系
+ * Whether the producer uses reactive and consumer to call, there is no connection
- * 当operation返回值为CompletableFuture类型时，默认此operation工作于reactive模式，此时如果需要强制此operation工作于线程池模式，需要在microservice.yaml中明确配置；假设某operation，其schemaId为sid，operationId为asyncQuery，则需要进行以下配置：
+ * When the operation return value is the CompletableFuture type, the default operation is in reactive mode. If you need to force this operation to work in thread pool mode, you need to configure it in microservice.yaml explicitly. If an operation, its schemaId is sid, operationId For asyncQuery, you need to do the following:
```
servicecomb:
@@ -141,21 +141,18 @@
sid.asyncQuery: cse.executor.groupThreadPool
```
-这里的cse.executor.groupThreadPool是serviceComb内置的默认线程池，用户可以任意指定为自己的定制线程池。
+The cse.executor.groupThreadPool here is the default thread pool built into serviceComb, which can be arbitrarily specified by the user as its custom thread pool.
-* Consumer：
+* Consumer:
- * consumer是否使用reactive与producer如何实现，没有任何联系
+ * Whether the consumer uses reactive and producer how to implement, there is no connection
- * 当前只支持透明RPC模式，使用JDK原生的CompletableFuture来承载此功能
+ * Currently only supports transparent RPC mode, using JDK native CompletableFuture to carry this function
- completableFuture的when、then等等功能都可直接使用
+ completableFuture's when, then, etc. can be used directly
- 但是completableFuture的async系列功能，其实是另外启线程池来执行功能，不建议使用
+ However, the async series of completableFuture is another thread pool to perform functions. It is not recommended.
- 关于RxJava Observable的支持后续会加入
+ Support for RxJava Observable will be added later.
- 关于AsyncRestTemplate的支持后续会加入
-
-
-
+ Support for AsyncRestTemplate will be added later.
diff --git a/java-chassis-reference/en_US/general-development/report-framework-version.md b/java-chassis-reference/en_US/general-development/report-framework-version.md
index b0437d6..f3ba2e8 100644
--- a/java-chassis-reference/en_US/general-development/report-framework-version.md
+++ b/java-chassis-reference/en_US/general-development/report-framework-version.md
@@ -1,59 +1,54 @@
-## 概念阐述
+## Concept Description
-为方便治理，使用ServiceComb进行开发，会将当前使用的ServiceComb版本号上报至服务中心，并且支持其他框架集成ServiceComb时上报其他框架的版本号。
+To facilitate the management, using ServiceComb for development, the currently used ServiceComb version number will be reported to the service center, and the version number of other frameworks will be reported when other frameworks integrate ServiceComb.
-## 示例代码
+## Sample Code
-步骤1 首先实现开源框架ServiceComb的Versions接口，实现该接口下的loadVersion方法，即可将版本名称和版本号作为键值对返回
+Step 1 First, implement the Versions interface of the open source framework ServiceComb, implement the loadVersion method under the interface, and return the version name and version number as key-value pairs.
```
public class MyVersion implements Versions{
- @Override
- public Map<String, String> loadVersion() {
- Map<String, String> map = new HashMap<>();
- map.put("My", this.getClass().getPackage().getImplementationVersion());
- return map;
- }
+ @override
+ public Map<String, String> loadVersion() {
+ Map<String, String> map = new HashMap<>();
+ map.put("My", this.getClass().getPackage().getImplementationVersion());
+ return map;
+ }
}
```
-步骤2 为了使用SPI机制让该返回对象被ServiceComb读取到，需要在META-INF中增加services文件夹，并在其中增加一个文件，以所实现接口x.x.x.Versions\(带包名\)为名，以具体实现类x.x.x.CseVersion\(带包名\)为内容
+Step 2 To use the SPI mechanism to make the returned object read by ServiceComb, you need to add the services folder in META-INF and add a file to it, with the name of the interface xxxVersions\ (with package name\). Take the concrete implementation class xxxCseVersion\ (with package name\) as the content
-当服务注册到ServiceCenter时，会携带所有版本号信息
+When the service is registered to the ServiceCenter, it will carry all version number information.
```
{
- "serviceId": "xxx",
- "appId": "xxx",
- "registerBy": "SDK",
- "framework": {
- "name": "servicecomb-java-chassis",
- "version": "My:x.x.x;ServiceComb:x.x.x"
- }
+ "serviceId": "xxx",
+ "appId": "xxx",
+ "registerBy": "SDK",
+ "framework": {
+ "name": "servicecomb-java-chassis",
+ "version": "My:x.x.x;ServiceComb:x.x.x"
+ }
}
```
-* 备注
+* Remarks
-上报的版本号可以自定义，也可以从pom或jar包的MANIFEST.MF里读取，如果使用.class.getPackage\(\).getImplementationVersion\(\)从MANIFEST.MF获取版本号，则需要在pom文件中把maven-jar-plugin的archive元素addDefaultImplementationEntries和addDefaultSpecificationEntries设置为true
+The reported version number can be customized, or it can be read from the MANIFEST.MF of the pom or jar package. If you use .class.getPackage\(\).getImplementationVersion\(\) to get the version number from MANIFEST.MF, you need to Set the maven-jar-plugin archive elements addDefaultImplementationEntries and addDefaultSpecificationEntries to true in the pom file.
```
<plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-jar-plugin</artifactId>
- <configuration>
- <archive>
- <manifest>
- <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
- <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
- </manifest>
- </archive>
- </configuration>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <configuration>
+ <archive>
+ <manifest>
+ <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+ <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+ </manifest>
+ </archive>
+ </configuration>
</plugin>
```
-
-
-
-
-
diff --git a/java-chassis-reference/en_US/general-development/secret-field.md b/java-chassis-reference/en_US/general-development/secret-field.md
index 6e86cf8..9a6a034 100644
--- a/java-chassis-reference/en_US/general-development/secret-field.md
+++ b/java-chassis-reference/en_US/general-development/secret-field.md
@@ -1,22 +1,22 @@
-## 场景描述
+## Scenario
-由于HTTP协议的非安全性，在网络中传输的数据能轻易被各种抓包工具监听。在实际应用中，业务对应用或服务间传输的敏感数据有较高的安全要求，这类数据需要特别的加密保护（业务不同对算法要求不同），这样即使内容被截获，也可以保护其中的敏感数据不被轻易获取。
+Due to the non-security of the HTTP protocol, data transmitted over the network can be easily monitored by various packet capture tools. In practical applications, services have high security requirements for sensitive data transmitted between applications or services. Such data requires special encryption protection (different services have different algorithm requirements) so that even if the content is intercepted, it can protect. Sensitive data is not easily obtained.
-## 解决方法
+## Solution
-服务间的通信离开不序列化和反序列化，对于上述的场景，使用jackson类库提供的 @JsonSerialize 和 @JsonDeserialize 注解功能，对敏感数据定制序列化和反序列化方法，并在定制化的方法中实现加解密功能。
+The communication between services leaves unserialized and deserialized. For the above scenario, the @JsonSerialize and @JsonDeserialize annotation functions provided by the jackson class library are used to customize the serialization and deserialization methods for sensitive data, and in a customized method. Implement encryption and decryption functions.
-注解描述参考：在 [https://github.com/FasterXML/jackson-databind/wiki](https://github.com/FasterXML/jackson-databind/wiki) 中查找对应版本的Javadocs
+Annotation descriptive reference: Find the corresponding version of Javadocs in [https://github.com/FasterXML/jackson-databind/wiki] (https://github.com/FasterXML/jackson-databind/wiki)
-## 示例
+##example
-1.对 Person 对象中的 name 属性，通过注解设定使用特定的序列化和反序列化方法。注：此处演示如何使用，不涉及加解密相关。
+1. Use the specific serialization and deserialization methods for annotations by setting the name property in the Person object. Note: This shows how to use it, not related to encryption and decryption.
```
public class Person {
private int usrId;
- //指定数据 name 使用特定的序列化和反序列化方法
+ // Specify data name using a specific serialization and deserialization method
@JsonSerialize(using = SecretSerialize.class)
@JsonDeserialize(using = SecretDeserialize.class)
private String name;
@@ -47,35 +47,32 @@
}
```
-2.定义 SecretSerialize 类 和 SecretDeserialize 类，并重写其方法
+2. Define the SecretSerialize class and the SecretDeserialize class and override their methods
```
public class SecretSerialize extends JsonSerializer<String> {
- //重写 name 的序列化方法，可在此实现用户定制的加解密或其他操作
+ // Rewrite the serialization method of a name, where you can implement custom encryption or decryption or other operations
@Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers)
throws IOException, JsonProcessingException {
- //在数据 name 后增加4个特定字符
+ // Add 4 specific characters after the data name
value = value + " &#@";
- //执行序列化操作
+ // Perform serialization operations
gen.writeString(value);
}
}
public class SecretDeserialize extends JsonDeserializer<String> {
- //重写 name 的反序列化方法，与serialize序列化方法匹配，按用户定制的规则获取真实数据
+ // Rewrite the deserialization method of a name, match the serialize serialization method, get the real data according to the rules customized by the user
@Override
public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
- //获取反序列化数据，除去4个特定字符，获取真实的 name
+ // Get the deserialized data, remove 4 specific characters, get the real name
String value = p.getValueAsString();
value = value.substring(0, value.length() - 4);
return value;
}
}
```
-
-
-
diff --git a/java-chassis-reference/zh_CN/general-development/cross-app-invocation.md b/java-chassis-reference/zh_CN/general-development/cross-app-invocation.md
index 097e542..1fcae26 100644
--- a/java-chassis-reference/zh_CN/general-development/cross-app-invocation.md
+++ b/java-chassis-reference/zh_CN/general-development/cross-app-invocation.md
@@ -40,7 +40,7 @@
@RpcReference(schemaId = "hello", microserviceName = "helloApp:helloProvider")
private Hello hello;
```
- 调用方式和调用同应用下的微服务相同：
+ 跨应用调用与同应用下调用微服务的方式相同：
```java
hello.sayHello("ServiceComb");
```
diff --git a/java-chassis-reference/zh_CN/general-development/dai-li-she-zhi.md b/java-chassis-reference/zh_CN/general-development/dai-li-she-zhi.md
index cbbc1f1..2b6f45e 100644
--- a/java-chassis-reference/zh_CN/general-development/dai-li-she-zhi.md
+++ b/java-chassis-reference/zh_CN/general-development/dai-li-she-zhi.md
@@ -1,6 +1,6 @@
## 背景
-作为一名开发者，在公司开发环境，可能是通过公司代理网络接入到因特网。如果调试服务时还必须依赖网上资源，比如直接连接华为共有云服务中心，那么就必须配置代理。
+作为一名开发者，在公司开发环境，可能是通过公司代理网络接入到因特网。如果调试服务时还必须依赖网上资源，比如直接连接共有云服务中心，那么就必须配置代理。
配置方式，在microservice.yaml文件增加proxy配置：
@@ -14,7 +14,7 @@
passwd: yourpassword #密码
```
-**注意：当前仅支持连接服务中心、配置中心、服务看板支持代理，如果对接其他三方服务，可以读取这个配置，自行配置代理，vertx httpclient支持代理设置，例如：**
+**注意：当前仅支持连接服务中心、配置中心支持代理，如果对接其他三方服务，可以读取这个配置，自行配置代理，vertx httpclient支持代理设置，例如：**
```java
HttpClientOptions httpClientOptions = new HttpClientOptions();
diff --git a/java-chassis-reference/zh_CN/general-development/dnsconfig.md b/java-chassis-reference/zh_CN/general-development/dnsconfig.md
index 461d462..a9e6221 100644
--- a/java-chassis-reference/zh_CN/general-development/dnsconfig.md
+++ b/java-chassis-reference/zh_CN/general-development/dnsconfig.md
@@ -1,6 +1,6 @@
## 场景描述
-用户使用域名连接华为公有云或者三方系统时，需要使用到域名解析系统。在不同的系统、不同的框架使用的域名解析机制都可能不太一样。所以我们有必要提供一个统一的配置入口，以便开发运维人员可以自定义DNS解析机制，而不完全受制于系统配置。
+用户使用域名连接公有云或者三方系统时，需要使用到域名解析系统。在不同的系统、不同的框架使用的域名解析机制都可能不太一样。所以我们有必要提供一个统一的配置入口，以便开发运维人员可以自定义DNS解析机制，而不完全受制于系统配置。
## DNS配置
@@ -24,7 +24,7 @@
``` yaml
addressResolver:
servers: 8.8.8.8,8.8.4.4 #对应Linux /etc/resolv.conf的nameserver,DNS服务器地址，支持配置多个，以逗号隔开
- ndots: 1 #对应linux /etc/resolv.conf里面的options: ndots, 作用就是如果给的域名里面包含的点的个数少于该阈值，那么DNS解析的时候就会默认加上searchDomains的值，这个必须和searchDomains搭配使用，Linux默认为1，华为公有云PAAS（包含容器）默认是4
+ ndots: 1 #对应linux /etc/resolv.conf里面的options: ndots, 作用就是如果给的域名里面包含的点的个数少于该阈值，那么DNS解析的时候就会默认加上searchDomains的值，这个必须和searchDomains搭配使用，Linux默认为1
searchDomains: a,b,c #对应linux /etc/resolv.conf里面的search，和ndots搭配使用，如果当前域名的点个数少于设置值，解析时就会把这些值添加到域名后面一起解析，比如ndots设置的为4，当前域名为servicecomb.cn-north-1.myhwclouds.com，只有三个点，那么解析的时候就会自动加上servicecomb.cn-north-1.myhwclouds.com.a去解析，没解析出来在用servicecomb.cn-north-1.myhwclouds.com.b，直到能最后解析出来
optResourceEnabled: true #optional record is automatically included in DNS queries
cacheMinTimeToLive: 0 #最小缓存时间
diff --git a/java-chassis-reference/zh_CN/general-development/file-download.md b/java-chassis-reference/zh_CN/general-development/file-download.md
index 1a039aa..4a313d5 100644
--- a/java-chassis-reference/zh_CN/general-development/file-download.md
+++ b/java-chassis-reference/zh_CN/general-development/file-download.md
@@ -59,8 +59,7 @@
因为InputStream不一定表示文件下载，所以需要通过swagger annotation（@ApiResponse）标识这是一个文件下载场景
-有的场景下，资源并不保存在本地，比如保存在OBS云服务中，而OBS资源是以InputStream方式输出的
-
+有的场景下，资源并不保存在本地
```
return ResponseEntity
.ok()
